- •Содержание
- •Рабочая учебная программа дисциплины По дисциплине «Java-технологии» специальности
- •5В060200 «Информатика»
- •5. Цель изучения дисциплины
- •6. Задачи изучения дисциплины
- •7. Содержание дисциплины
- •8. Календарно-тематический план изучения дисциплины «Статистика»
- •9. План лекций, практических (семинарских), лабораторных занятий
- •11. График выполнения и сдачи заданий по срс
- •10. График проведения срсп
- •12. Тематика курсовых работ
- •13. Список основной и дополнительной литературы
- •13.1 Основная литература.
- •13.2 Дополнительная литература.
- •(С ключами правильных ответов)
- •4. Что будет выведено на экран, если скомпилировать и запустить следующий код:
- •5. Какой результат работы программы:
- •6. После выполнения какой строки только один объект будет доступен для сборки мусора (Garbage Collection)?
- •7. Какой результат выдаст следующий код?
- •16. Что произойдёт если скомпилировать следующий код?
- •2. Каким будет результат компиляции и выполнения следующего кода?
- •3. Что выведет на экран следующий код ?
- •4. Что произойдет в результате компиляции и выполнения следующей программы?
- •6. Каким будет результат компиляции и выполнения данного кода:
- •7. Что выведет данный код:
- •8. Выберите строки, использование которых в строке 7 не приведет к ошибке компиляции.
- •14. Возникнет ли ошибка компиляции в следующем фрагменте кода:
- •15. Что произойдёт если скомпилировать и выполнить следующий код?
- •16. Что выведет следующий код?
- •17. Сколько объектов будет создано в результате следующей операции:
- •18. Определим такую функцию
- •19. Выберите единственный верный результат компиляции и выполнения кода.
- •20. Сколько денег в кармане у Джека?
- •14.2. Теоретические вопросы для проведения 2 рубежного контроля
- •14.3. Тематика письменных работ (рефераты) для проведения
- •2 Рубежного контроля
- •4. Что будет выведено на экран, если скомпилировать и запустить следующий код:
- •5. Какой результат работы программы:
- •6. После выполнения какой строки только один объект будет доступен для сборки мусора (Garbage Collection)?
- •7. Какой результат выдаст следующий код?
- •16. Что произойдёт если скомпилировать следующий код?
- •22. Каким будет результат компиляции и выполнения следующего кода?
- •23. Что выведет на экран следующий код ?
- •24. Что произойдет в результате компиляции и выполнения следующей программы?
- •26. Каким будет результат компиляции и выполнения данного кода:
- •27. Что выведет данный код:
- •28. Выберите строки, использование которых в строке 7 не приведет к ошибке компиляции.
- •34. Возникнет ли ошибка компиляции в следующем фрагменте кода:
- •35. Что произойдёт если скомпилировать и выполнить следующий код?
- •36. Что выведет следующий код?
- •37. Сколько объектов будет создано в результате следующей операции:
- •38. Определим такую функцию
- •39. Выберите единственный верный результат компиляции и выполнения кода.
- •40. Сколько денег в кармане у Джека?
- •41. Выберите единственный верный результат компиляции и выполнения кода.
- •42. Выберите правильный результат выполнения кода:
- •43. Что напечатает следующий код:
- •44. Что напечатает следующий код:
- •46. Что выдаст следующий код?
- •47. Что будет выведено на экран в результате выполнения следующего кода?
- •48. Что выведется на экран:
- •49. Что произойдет в результате компиляции и выполнения кода:
- •50. Какой будет результат компиляции и выполнения кода?
- •I. Какие буквы напечатает данная программа?
- •15.2 Теоретические вопросы для подготовки к экзамену
- •15.3 Методические указания (рекомендации) по выполнению экзаменационной контрольной работы
- •16. Система оценки знаний студента
- •16.1 Шкала выставления рейтинга студента дневного отделения
- •16.2 Шкала выставления рейтинга студента заочного отделения
- •16.2 Расчет итоговой оценки
- •16.3 Балльно-рейтинговая система оценки учебных достижений студента с переводом в традиционную шкалу оценок
- •5В060200 «Информатика»
- •Лекция 2. Основы объектно-ориентированного программирования
- •Лекция 3. Лексика языка
- •V circle. Get/*commentVRadius();
- •2. Comment
- •4. More comments
- •6. Finish
- •Лекция 4. Типы данных
- •Лекция 5. Имена. Пакеты
- •Import java.Net.Url;
- •Import java.Awt.*;
- •Import Java.Awt.*;
- •Import Java.Awt.*;
- •Interface Mylnterface { }
- •Inti.J.K; long I;
- •Лекция 6. Объявление классов
- •Import first.*;
- •IntgetXo {return х;}
- •7 Public class One {
- •V public class Two {// Единственный конструктор класса Second.
- •Initializer getVo о initializer2 TestO
- •Лекция 7. Преобразование типов
- •Лекция 8. Объектная модель в Java
- •Interface а { intgetValueO;}
- •Interface в {double getValue{);}
- •Лекция 9. Массивы
- •Лекция 10. Операторы и структура кода. Исключения
- •1Ы: {System.Out.Println("Block 1");
- •1.1. Консольные приложения
- •1.2. Выполнение Java-программы
- •1.3. Апплеты. Основные принципы создания
- •1.4. Умножение матрицы на вектор
- •1.5. Вычисление значений дробно-рациональной функции комплексного переменного
- •1.6.Выбор фигуры
- •1.7. Создание заставки
- •Import java.Awt.*;
- •Import java.Awt.*;
- •Import java.Applet.*;
- •Import java.Awt.*;
- •Import java.Math.*;
- •Import java.Applet.*;
- •1.11. Построение изолиний функции двух переменных
- •1.11. Работа с паролем
- •Import java.Applet.*;
- •Import java.Awt.*;
- •1. Методические рекомендации по выполнению заданий
- •2. Форма контроля
- •3. Оценочный балл выполнения задания
- •Задание №1.
- •Задание №3
- •Задание №4
- •Задание №5
- •Задание №6
- •Задание №6
Лекция 7. Преобразование типов
Эта лекция посвящена вопросам преобразования типов. Поскольку Java язык строго типизированный, компилятор и виртуальная машина всегда следят за работой с типами, гарантируя надежность выполнения программы. Однако во многих случаях то или иное преобразование необходимо осуществить для реализации логики программы, с другой стороны, некоторые безопасные переходы между типами Java позволяет осуществлять неявным для разработчика образом, что может привести к неверному пониманию работы программы.
В лекции рассматриваются все виды преобразований, а затем все ситуации в программе, где они могут применяться. В заключение приводится начало классификации типов переменных и типов значений, которые они могут хранить. Этот вопрос будет подробнее рассматриваться в следующих лекциях.
Введение
Как уже говорилось, Java является строго типизированным языком, а это означает, что каждое выражение и каждая переменная имеет строго определенный тип уже на момент компиляции. Тип устанавливается на основе структуры применяемых выражений и типов литералов, переменных и методов, используемых в этих выражениях.
Например:
long а=3;
а = 5+'АЧа;
print("a="+Math.rouncl(a/2F));
Рассмотрим, как в этом примере компилятор устанавливает тип тихого выражения и какие преобразования (conversion) типов необходимо осуществить при каждом действии.
• В первой строке литерал 3 имеет тип по умолчанию, то есть int. При присвоении этого значения переменной типа long необходимо провести преобразование.
• Во второй строке сначала производится сложение значений типа int и char. Второй аргумент будет преобразован так, чтобы операция проводилось с точностью в 32 бита. Второй оператор сложения опять потребует преобразования, так как наличие переменной а увеличивает точность до 64 бит.
•в третьей строке сначала будет выполнена операция деления, для чего значение long надо будет привести к типу float, так как второй операнд — дробный литерал. Результат будет передан в метод Math.round, который произведет математическое округление и вернет целочисленный результат типа int. Это значение необходимо преобразовать текст, чтобы осуществить дальнейшую конкатенацию строк. Как будет показано ниже, эта операция проводится в два этапа — сначала простой тип приводится к объектному классу "обертке" (в данном случае int к Integer), а затем у полученного объекта вызывается метод toString(), что дает преобразование к строке.
Данный пример показывает, что даже простые строки могут содержать многочисленные преобразования, зачастую незаметные для разработчика. Часто бывают и такие случаи, когда программисту необходимо явно изменить тип некоторого выражения или переменной, например, чтобы воспользоваться подходящим методом или конструктором.
Вспомним уже рассмотренный пример:
byteb=1;
byte c={byte)-b;
int i=c;
Здесь во второй строке необходимо провести явное преобразование, чтобы присвоить значение типа byte переменной типа int. В третьей же строке обратное приведение производится автоматически, неявным для разработчика образом.
Рассмотрим сначала, какие переходы между различными типами можно осуществить.
Виды приведений
В Java предусмотрено семь видов приведений:
• т ождественное (identity);
• расширение примитивного типа (widening primitive);
• сужение примитивного типа (narrowing primitive);
• расширение объектного типа (widening reference);
• сужение объектного типа (narrowing reference);
• преобразование к строке (String);
• запрещенные преобразования (forbidden). Рассмотрим их по отдельности.
Тождественное преобразование
Самым простым является тождественное преобразование. В Java преобразование выражения любого типа к точно такому же типу всегда допустимо и успешно выполняется.
Зачем нужно тождественное приведение? Есть две причины для того, чтобы выделить такое преобразование в особый вид.
Во-первых, с теоретической точки зрения теперь можно утверждать, что любой тип в Java может участвовать в преобразовании, хотя бы в тождественном. Например, примитивный тип booleanнельзя привести ни к какому другому типу, кроме него самого.
Во-вторых, иногда в Java могут встречаться такие выражения, как длинный последовательный вызов методов:
print(getCity().getStreet().getHouse().getFlat().getRoom());
При исполнении такого выражения сначала вызывается первый метод getCity(). Можно предположить, что возвращаемым значением будет объект класса City. У этого объекта далее будет вызван следующий метод getStreet(). Чтобы узнать, значение какого типа он вернет, необходимо посмотреть описание класса City. У этого значения будет вызван следующий метод (getHouseO), и так далее. Чтобы узнать результирующий тип всего выражения, необходимо просмотреть описание каждого метода и класса.
Компилятор без труда справится с такой задачей, однако разработчику будет нелегко проследить всю цепочку. В этом случае можно воспользоваться тождественным преобразованием, выполнив приведение к точно такому же типу. Это ничего не изменит в структуре программы, но значительно облегчит чтение кода:
print((MyFlatlmpl)(getCity().getStreet(). getHouseO. getFlatO));
Преобразование примитивных типов (расширение и сужение)
Очевидно, что следующие четыре вида приведений легко представляется в виде таблицы 7.1.
Табл. 7.1. Виды приведений.
Что все это означает? Начнем по порядку. Для простых типов расширение означает, что осуществляется переход от менее емкого типа к более емкому, например, от типа byte (длина 1 байт) к типу int (длина 4 байта). Такие преобразования безопасны в том смысле, что новый тип всегда гарантированно вмещает в себя все данные, которые хранились в старом типе, и таким образом не происходит потери данных. Именно поэтому компилятор осуществляет его сам, незаметно для разработчика:
byte b=3; int a=b;
В последней строке значение переменной b типа byte будет преобразовано к типу переменной а (то есть, int) автоматически, никаких специальных действий для этого предпринимать не нужно.
Следующие 19 преобразований являются расширяющими:
• от byte к short, int, long, float, double
• от short к Int, long, float, double
• от char к int, long, float, double
• от int к long, float, double
• от long к float, double
• от float к double
Обратите внимание, что нельзя провести преобразование к типу char от типов меньшей или равной длины (byte, short), или, наоборот, к short от char без потери данных. Это связано с тем, что char, в отличие от остальных целочисленных типов, является беззнаковым.
Тем не менее, следует помнить, что даже при расширении данные все-таки могут быть в особых случаях искажены. Они уже рассматривались в предыдущей лекции, это приведение значений Intк типу float и приведение значений типа long к типу float или double. Хотя эти дробные типы вмешают гораздо большие числа, чем соответствующие целые, но у них меньше значащих разрядов.
Повторим этот пример:
longa=111111111111L; float f = а; а = (long) f; print(a);
Результатом будет:
111111110656
Обратное преобразование — сужение — означает, что переход осуществляется от более емкого типа к менее емкому. При таком преобразовали, есть риск потерять данные. Например, если число типа int было больше 127, то при приведении его к byte значения битов старше восьмого будут потеряны. В Java такое преобразование должно совершаться явным образом, т.е. программист в коде должен явно указать, что он намеревается осуществить такое преобразование и готов потерять данные.
Следующие 23 преобразования являются сужающими:
• от byte к char
• от short к byte, char
• от char к byte, short
• от int к byte, short, char
• от long к byte, short, char, Int
• от float к byte, short, char, Int, long
• от double к byte, short, char, Int, long, float
При сужении целочисленного типа к более узкому целочисленному все старшие биты, не попадающие в новый тип, просто отбрасываются. Не производится никакого округления или других действий для получения более корректного результата:
prlnt((byte)383): prlnt((byte)384); prlnt((byte)-384);
Результатом будет:
127
-128
-128
Видно, что знаковый бит при сужении не оказал никакого влияния, "^^ как был просто отброшен — результат приведения обратных чисел (384 и -384) оказался одинаковым. Следовательно, может быть потеряно Не только точное абсолютное значение, но и знак величины.
Это верно и для типа char:
char с=40000; Pnnt((short)c);
Результатом будет:
-25536
Сужение дробного типа до целочисленного является более сложной процедурой. Она проводится в два этапа.
На первом шаге дробное значение преобразуется в long, если целевым типом является long, или в int — в противном случае (целевой тип byte, short, char или int). Для этого исходное дробное число сначала математически округляется в сторону нуля, то есть дробная часть просто отбрасывается.
Например, число 3,84 будет округлено до 3, а -3,84 превратится в -3. При этом могут возникнуть особые случаи:
• если исходное дробное значение является Nan, то результатом первого шага будет 0 выбранного типа (т.е. int или long);
• если исходное дробное значение является положительной или отрицательной бесконечностью, то результатом первого шага будет, соответственно, максимально или минимально возможное значение для выбранного типа (т.е. для int или long);
• наконец, если дробное значение было конечной величиной, но в результате округления получилось слишком, большое по модулю число для выбранного типа (т.е. для int или long), то, как и в предыдущем пункте, результатом первого шага будет, соответственно, максимально или минимально возможное значение этого типа. Если же результат округления укладывается в диапазон значений выбранного типа, то он и будет результатом первого шага.
На втором шаге производится дальнейшее сужение от выбранного целочисленного типа к целевому, если таковое требуется, то есть может иметь место дополнительное преобразование от int кbyte, short или char.
Проиллюстрируем описанный алгоритм преобразованием от бесконечности ко всем целочисленным типам:
float fmin = Float.NEGATIVEJNFINITY; float fmax = Float.POSITIVEJNFINITY; print("long:" н- (long)fnnin н-".." н- (long)fmax); print("int:" + (int)fmin + ".." •*- (int)fmax); print("short:" -*- (short)fnnin + ".." + (short)fnnax); print("char:" + (int)(char)fmin +".." + (int)(char)fmax); print("byte:" + (byte)fmin + ".." + (byte)fnnax);
Результатом будет:
long: -9223372036854775808. .9223372036854775807
int: -2147483648..2147483647
short: 0..-1
char: 0..65535
byte:0..-1
Значения long и int вполне очевидны — дробные бесконечности преобразовались в, соответственно, минимально и максимально воз-1^оЖные значения этих типов. Результат для следующих трех типов (short, char, byte) есть, по сути, дальнейшее сужение значений, полученных для int, согласно второму шагу процедуры преобразования. А делается это, как было описано, просто за счет отбрасывания старших битов. Вспомним, что минимально возможное значение в битовом виде представляется как 1000..000 (всего 32 бита для int, то есть единица и 31 ноль). Максимально возможное 1111..111 (32 единицы). Отбрасывая старшие биты, получаем для отрицательной бесконечности результат 0, одинаковый для всех трех типов. Для положительной же бесконечности получаем результат, все биты которого равняются 1. Для знаковых типов byte и short такая комбинация рассматривается как -1, а для без знакового char - как максимально возможное значение, то есть 65535.
Может сложиться впечатление, что для char приведение дает точное значение. Однако это был частный случай - отбрасывание битов в большинстве случаев все же дает искажение. Например, сужение дробного значения 2 миллиарда:
float f=2e9f;
pnnt((int)(char)f);
print((int)(char)-f);
Результатом будет:
37888 27648
Обратите внимание на двойное приведение для значений типа char в двух последних примерах» Понятно, что преобразование от char к int не приводит к потере точности, но позволяет распечатывать не символ, а его числовой код, что более удобно для анализа.
В заключение еще раз обратим внимание на то, что примитивные значения типа boolean могут участвовать только в тождественных преобразованиях.
Преобразование ссылочных типов (расширение и сужение)
Переходим к ссылочным типам. Преобразование объектных типов всего иллюстрируется с помощью дерева наследования. Рассмотрим большой пример наследования:
// Объявляем класс Parent class Parent {intx; }
// Объявляем класс Child и наследуем // его от класса Parent class Child extends Parent {inty; }
// Объявляем второго наследника // класса Parent - класс Child2 class Child2 extends Parent {intz;}
В каждом классе объявлено поле с уникальным именем. Будем рассматривать это поле, как пример набора уникальных свойств, присущих некоторому объектному типу.
Три объявленных класса могут порождать три вида объектов. Объекты класса Parent обладают только одним полем х, а значит, только ссылки типа Parent могут ссылаться на такие объекты. Объекты класса Child обладают полем у и полем х, полученным по наследству от класса Parent. Стало быть, на такие объекты могут указывать ссылки типа Child или Parent. Второй случай уже иллюстрировался следующим примером:
Parent р = new Child();
Обратите внимание, что с помощью такой ссылки р можно обращаться лишь к полю X созданного объекта. Поле у недоступно, так как компилятор, проверяя корректность выражения р.у, не может предугадать, что ссылка р будет указывать на объект типа Child во время исполнения программы. Он анализирует лишь тип самой переменной, а она объявлена как Parent, но в этом классе нет поля у, что и вызовет ошибку компиляции.
Аналогично, объекты класса Child2 обладают полем z и полем х, полученным по наследству от класса Parent. Значит, на такие объекты могут указывать ссылки типа Child2 или Parent.
Таким образом, ссылки типа Parent могут указывать на объект любого из трех рассматриваемых типов, а ссылки типа Child и Child2 – только а объекты точно такого же типа. Теперь можно перейти к преобразованию ссылочных типов на основе такого дерева наследования.
Расширение означает переход от более конкретного типа к менее конкретному, т.е. переход от детей к родителям. В нашем примере преобразование от любого наследника (Child, Child2) к родителю (Parent) есть расширение, переход к более общему типу. Подобно случаю с примитивными типами, этот переход производится самой JVM при необходимости и незаметен для разработчика, то есть не требует никаких дополнительных усилий, так как он всегда проходит успешно: всегда можно обращаться к объекту, порожденному от наследника, по типу его родителя.
Parent p1=new Child О; Parent p2=new Child2();
В обеих строках переменным типа Parent присваивается значение другого типа, а значит, происходит преобразование. Поскольку это расширение, оно производится автоматически и всегда успешно.
Обратите внимание, что при подобном преобразовании с самим объектом ничего не происходит. Несмотря на то, что, например, поле у класса Child теперь недоступно, это не означает, что оно исчезло. Такое существенное изменение структуры объекта невозможно. Он был порожден от класса Child и сохраняет все его свойства. Изменился лишь тип ссылки, через которую идет обращение к объекту. Эту ситуацию можно условно сравнить с рассматриванием некоего предмета через подзорную трубу если перейти от трубы с большим увеличением к более слабой, то видимых деталей станет меньше, но сам предмет, конечно, никак от этого не изменится.
Следующие преобразования являются расширяющими:
• от класса А к классу В, если А наследуется от В (важным частным случаем является преобразование от любого ссылочного типа к Object);
• от null-типа к любому объектному типу
Второй случай иллюстрируется следующим примером:
Parent p=null;
Пустая ссылка null не обладает каким-либо конкретным ссылочным узлом, поэтому иногда говорят о специальном null-типе. Однако на практике важно, что такое значение можно прозрачно преобразовать к любому векторному типу
С Изучением остальных ссылочных типов (интерфейсов и массивов)
список будет расширяться.
Обратный переход, то есть движение по дереву наследования вниз, наследникам, является сужением. Например, для рассматриваемого случая, переход от ссылки типа Parent, которая может ссылаться на объекты трех классов, к ссылке типа Child, которая может ссылаться на объекты лишь одного из трех классов, очевидно, является сужением. Такой переход может оказаться невозможным. Если ссылка типа Parent ссылается на объект типа Parent или Child2, то переход к Child невозможен, ведь в обоих случаях объект не обладает полем у, которое объявлено в классеChild. Поэтому при сужении разработчику необходимо явным образом указывать на то, что необходимо попытаться провести такое преобразование. JVM во время исполнения проверит корректность перехода. Если он возможен, преобразование будет проведено. Если же нет - возникнет ошибка.
Parent p=newChild();
Child c=(Child)p; // преобразование будет успешным.
Parent p2=new Child2();
Child c2=(Child)p2; // во время исполнения возникнет ошибка!
Чтобы проверить, возможен ли желаемый переход, можно воспользоваться оператором instanceof: Parent p=new Child(); if (p instanceof Child) { Child с = (Child)p;}
Parent p2=newChild2(); if (p2 instanceof Child) { Child с = (Child)p2;}
Parent p3=new Parent();
if (p3 instanceof Child) {Childc = (Child)p3; }
В данном примере ошибок не возникнет. Первое преобразование возможно, и оно будет осуществлено. Во втором и третьем случаях условия операторов if не сработают и попыток некорректного перехода не будет.
На данный момент можно назвать лишь одно сужающее преобразование:
• от класса А к классу В, если В наследуется от А (важным частным случаем является сужение типа Object до любого другого ссылочного типа)-
С изучением остальных ссылочных типов (интерфейсов и массивов) этот список будет расширяться.
Преобразование к строке
Это преобразование уже не раз упоминалось. Любой тип может быть приведен к строке, т.е. к экземпляру класса String. Такое преобразование является исключительным в силу того, что охватывает абсолютно все типы, в том числе и boolean, про который говорилось, что он не может участвовать ни в каком другом приведении, кроме тождественного.
Напомним, как преобразуются различные типы.
• Числовые типы записываются в текстовом виде без потери точности представления. Формально такое преобразование происходит в два этапа. Сначала на основе примитивного значения порождается экземпляр соответствующего класса-"обертки", а затем у него вызывается метод toString(). Но поскольку эти действия снаружи незаметны, многие JVM оптимизируют их и преобразуют примитивные значения в текст напрямую.
• Булевская величина приводится к строке "true" или "false" в зависимости от значения.
• Для объектных величин вызывается метод toString(). Если метод возвращает null, то результатом будет строка "null".
• Для null-значения генерируется строка "null".
Запрещенные преобразования
Не все переходы между произвольными типами допустимы. Например, к запрещенным преобразованиям относятся: переходы от любого ссылочного типа к примитивному от примитивного - к ссылочному (кроме преобразований к строке). Уже упоминавшийся пример — тип boolean нельзя привести ни к какому другому типу, кроме boolean (как обычно за исключением приведения к строке). Затем, невозможно привести Друг к другу типы, находящиеся не на одной, а на соседних ветвях дерева наследования. В примере, который рассматривался для иллюстрации преобразований ссылочных типов, переход от Child к Child2 запрещен. В самом деле, ссылка типа Child может указывать на объекты, порожденные только от класса Child или его наследников. Это исключает вероятность того, что объект будет, совместим с типом Child2.
Этим список запрещенных преобразований не исчерпывается. Он дольно велик, и в то же время все варианты достаточно очевидны, поэтому подробно рассматриваться не будут. Желающие могут получить пол-
информацию из спецификации.
Разумеется, попытка осуществить запрещенное преобразование вызовет ошибку компиляции.
Применение приведений
Теперь, когда рассмотрены все виды преобразований, перейдем к ситуациям в коде, где могут встретиться или потребоваться приведения. Такие ситуации могут быть сгруппированы следующим образом.
• Присвоение значений переменным (assignment). Не все переходы допустимы при таком преобразовании - ограничения выбраны таким образом, чтобы не могла возникнуть ошибочная ситуация.
• Вызов метода. Это преобразование применяется к аргументам вызываемого метода или конструктора. Допускаются почти те же переходы, что и для присвоения значений. Такое приведение никогда не порождает ошибок. Так же приведение осуществляется при возвращении значения из метода.
• Явное приведение. В этом случае явно указывается, к какому типу требуется привести исходное значение. Допускаются все виды преобразований, кроме приведений к строке и запрещенных. Может возникать ошибка времени исполнения программы.
• Оператор конкатенации производит преобразование к строке своих аргументов.
• Числовое расширение (numeric promotion). Числовые операции могут потребовать изменения типа аргумента(ов). Это преобразование имеет особое название — расширение (promotion), так каквыбор целевого типа может зависеть не только от исходного значения, но и от второго аргумента операции.
Рассмотрим все случаи более подробно.
Присвоение значений
Такие ситуации неоднократно применялись в этой лекции для иллюстрации видов преобразования. Приведение может потребоваться, если переменной одного типа присваивается значение другого типа. Возможны следующие комбинации.
Если сочетание этих двух типов образует запрещенное приведение, возникнет ошибка. Например, примитивные значения нельзя присваивать объектным переменным, включая следующие примеры;
// пример вызовет ошибку компиляции
// примитивное значение нельзя // присвоить объектной переменной
parent р = 3;
// приведение к классу-"обертке" также запрещено Long a=5L;
// универсальное приведение к строке // возможно только для оператора + String s=true;
Далее, если сочетание этих двух типов образует расширение (примитивных или ссылочных типов), то оно будет осуществлено автоматичес-01^ неявным для разработчика образом:
lnti=10;
long a=i;
Child с = new ChlldO;
Parent p=c;
Если же сочетание оказывается сужением, то возникает ошибка компиляции, такой переход не может быть проведен неявно:
// пример вызовет ошибку компиляции
inti=10;
short s=i; // ошибка! сужение!
Parent р = new ChildO;
Child c=p; // ошибка! сужение!
Как уже упоминалось, в подобных случаях необходимо выполнять преобразование явно:
inti=10; short s=(lnt)l; Parent р = new Chlld(); Child c=(Chlld)p;
Более подробно явное сужение рассматривается ниже. Здесь может вызвать удивление следующая ситуация, которая не порождает ошибок компиляции:
byteb=1; short S=2-H3; Char c=(byte)5-i-'a';
в первой строке переменной типа byte присваивается значение цело, численного литерала типа int, что является сужением. Во второй строке переменной типа short присваивается результат сложения двух литералов типа int, а тип этой суммы также int. Наконец, в третьей строке переменной типа char присваивается результат сложения числа 5, приведенного ^ типу byte, и символьного литерала.
Однако все эти примеры корректны. Для удобства разработчика компилятор проводит дополнительный анализ при присвоении значении переменным типа byte, short и char. Если таким переменным присваивается величина типа byte, short, char или int, причем ее значение может быть получено уже на момент компиляции, и оказывается, что это значение укладывается в диапазон типа переменной, то явного приведения не требуется. Если бы такой возможности не было, пришлось бы писать так:
byte b=(byte)1; // преобразование необязательно short s=(short)(2+3); // преобразование необязательно char c=(char)((byte)5+'a'); // преобразование необязательно
// преобразование необходимо, так как // число 200 не укладывается в тип byte byte b2-(byte)200;
Вызов метода
Это приведение возникает в случае, когда вызывается метод с объявленными параметрами одних типов, а при вызове передаются аргументы других типов. Объявление методов рассматривается в следующих лекциях курса, однако такой простой пример вполне понятен:
// объявление метода с параметром типа long voidcalculate(long I) {}
void main() {calculate(5); }
Как видно, при вызове метода передается значение типа int, а не long, как определено в объявлении этого метода.
Здесь компилятор предпринимает те же шаги, что и при приведении g процессе присвоения значений переменным. Если типы образуют запрещенное преобразование, возникнет ошибка.
// пример вызовет ошибку компиляции
void calculate(long а) {}
void main() {calculate(new Long(5)); // здесь будет ошибка}
Если сужение, то компилятор не сможет осуществить приведение и потребуются явные указания.
void calculate(int а) {}
void main() {long a=5;
// calculate(a); // сужение! так будет ошибка.
calculate((int)a); // корректный вызов }
Наконец, в случае расширения, компилятор осуществит приведение сам, как и было показано в примере в начале этого раздела.
Надо отметить, что, в отличие от ситуации присвоения, при вызове Методов компилятор не производит преобразований примитивных значений от byte, short, char или int к byte, short или char. Это привело бы к умножению работы с перегруженными методами. Например:
// пример вызовет ошибку компиляции
// объявляем перегруженные методы // с аргументами (byte, int) и (short, short) int m(byte a, int b) {return a+b;} int m(short a, short b) {return a-b;}
void main() {print(nn(12, 2)); // ошибка компиляции! }
в этом примере компилятор выдаст ошибку, так как при вызове аргументы имеют тип (Int, int), а метода с такими параметрами нет. Если бы компилятор проводил преобразование для целых величин, подобно ситуации с присвоением значений, то пример стал бы корректным, но пришлось бы прилагать дополнительные усилия, чтобы указать, какой из двух возможных перегруженных методов хотелось бы вызвать.
Аналогичное преобразование потребуется при возвращении значения из метода, если тип результата и заявленный тип возвращаемого значения не совпадают.
longget(){ return 5; }
Хотя в выражении return указан целочисленный литерал типа Int, во всех местах, где будет вызван этот метод, будет получено значение типа long. Для такого преобразования действуют те же правила, что и для присвоения значения.
В заключение рассмотрим пример, включающий в себя все рассмотренные случаи преобразования:
short get(Parent р) {
return 5+'А'; // приведение при возвращении значения }
void main() {
long а = // приведение при присвоении значения get(newChild()); // приведение при вызове метода
}
Явное приведение
Явное приведение уже многократно использовалось в примерах. При таком преобразовании слева от выражения, тип значения которого необходимо преобразовать, в круглых скобках указывается целевой тип. Если преобразование пройдет успешно, то результат будет точно указанного типа. Примеры:
(byte)5
(Parent)newChild()
(Flat)getClty{).getStreet().getHouse().getFlat()
Если комбинация типов образует запрещенное преобразование, возникает ошибка компиляции. Допускаются тождественные преобразования, расширения простых и объектных типов, сужения простых и объектных типов. Первые три всегда выполняются успешно. Последние два могут стать причиной ошибки исполнения, если значения оказались несовместимыми. Как следствие, выражение null всегда может быть успешно прeoбpaзoвaнo к любому ссылочному типу.
Но можно найти способ все-таки закодировать запрещенное преобразование.
Child c=newChlld();
// Chlld2 c2=(Child2)c; // запрещенное преобразование
Parent р=с; // расширение
Child2 c2=(Chlld2)p; // сужение
Такой код будет успешно скомпилирован, однако, разумеется, при исполнении он всегда будет генерировать ошибку в последней строке. "Обманывать" компилятор смысла нет.
Оператор конкатенации строк
Этот оператор уже рассматривался достаточно подробно. Если обоими его аргументами являются строки, то происходит обычная конкатенация. Если же тип String имеет лишь один из аргументов, то второй необходимо преобразовать в текст. Это единственная операция, при которой производится универсальное приведение любого значения к типу String.
Это одно из свойств, выделяющих класс String из общего ряда.
Правила преобразования уже были подробно описаны в этой лекции, а оператор конкатенации рассматривался в лекции "Типы данных".
Небольшой пример:
int 1=1;
double d=i/2.;
String s="text";
print("i="+i+", d="+d+", s="+s);
Результатом будет:
i=1,d=0.5, s=text
Числовое расширение
Наконец, последний вид преобразований применяется при числовых операциях, когда требуется привести аргумент(ы) к типу длиной в 32 или 64 бита для проведения вычислений. Таким образом, при числовом расширении осуществляется только расширение примитивных типов.
Различают унарное и бинарное числовое расширение.
Унарное числовое расширение
Это преобразование расширяет примитивные типы byte, short или char до типов int по правилам расширения примитивных типов.
Унарное числовое расширение может выполняться при следующих операциях:
• унарные операции + и -;
• битовое отрицание -;
Ф операции битового сдвига <<,»,>>>.
Операторы сдвига имеют два аргумента, но они расширяются независимо друг от друга, поэтому данное преобразование является унарным. Таким образом, результат выражения 5<<3L имеет тип int. Вообще, результат операторов сдвига всегда имеет тип int или long.
Примеры работы всех этих операторов с учетом расширения подробно рассматривались в предыдущих лекциях.
Бинарное числовое расширение
Это преобразование расширяет все примитивные числовые типы, кроме double, до типов int, long, float, double по правилам расширения примитивных типов. Бинарное числовое расширение происходит при числовых операторах, имеющих два аргумента, по следующим правилам:
• если любой из аргументов имеет тип double, то и второй приводится к double;
• иначе, если любой из аргументов имеет тип float, то и второй приводится к float;
• иначе, если любой из аргументов имеет тип long, то и второй приводится к long;
• иначе оба аргумента приводятся к int.
Бинарное числовое расширение может выполняться при следующих операциях:
• арифметические операции +,-,*,/,%;
• операции сравнения <, <=, >, >=, ==, !=;
• битовые операции &, |, '';
• в некоторых случаях для операции с условием ? :.
Примеры работы всех этих операторов с учетом расширения подробно рассматривались в предыдущих лекциях.
Тип переменной и тип ее значения
Теперь, когда были подробно рассмотрены все примеры преобразований, нужно вернуться к вопросу переменной и ее значений.
Как уже говорилось, переменная определяется тремя базовыми характеристиками: имя, тип, значение. Имя дается произвольным образом и никак не сказывается на свойствах переменной. А вот значение всегда имеет некоторый тип, не обязательно совпадающий с типом самой переменной. Поэтому необходимо рассмотреть все возможные типы переменных и выяснить, значения каких типов они могут иметь.
Начнем с переменных примитивных типов. Поскольку эти переменные действительно хранят само значение, то их тип всегда точно совпадает с типом значения.
Проиллюстрируем это правило на примере:
byte b=3; char с='А'+3; long nn=b+c; double cl=m-3F;
Здесь переменная b будет хранить значение типа byte после сужения целочисленного литерала типа int. Переменная с будет хранить тип char после того, как компилятор осуществит сужающее преобразование результата суммирования, который будет иметь тип int. Для переменной m выполнится расширение результата суммирования типа от int к типу long. Наконец, переменная d будет хранить значение типа double, получившееся в результате расширения результата разности, который имеет тип float.
Переходим к ссылочным типам. Во-первых, значение любой перееденной такого типа - ссылка, которая может указывать лишь на объекты, Порожденные от тех или иных классов, и далее обсуждаются только свойва данных классов. (Также объекты могут порождаться от массивов, эта тема рассматривается в отдельной лекции.)
Кроме того, ссылочная переменная любого типа может иметь значение null. Большинство действий над такой переменной, например, обращение к полям или методам, приведет к ошибке.
И так, какова связь между типом ссылочной переменной и ее значения? Здесь главное ограничение — проверка компилятора, который следит, чтобы все действия, выполняющиеся над объектом, были корректны. ^Компилятор не может предугадать, на объект какого класса будет реально
ссылаться та или иная переменная. Все, чем он располагает, — тип самой переменной. Именно его и использует компилятор для проверок. А значит, все допустимые значения переменной должны гарантированно обладать свойствами, определенными в классе-типе этой переменной. Такую гарантию дает только наследование. Отсюда получаем правило: ссылочная переменная типа А может указывать на объекты, порожденные от самого типа А или его наследников.
Point р = newPoJntO;
В этом примере переменная и ее значение одинакового типа, поэтому над объектом можно совершать все возможные для данного класса действия.
Parent р = new ChildO;
Такое присвоение корректно, так как класс Child порожден от Parent. Однако теперь допустимые действия над переменной р, а значит, над объектом, только что созданным на основе класса Child, ограничены возможностями класса Parent. Например, если в классе Child определен некий новый метод newChildMethodO, то попытка его вызвать p.newChildMethod() будет порождать ошибку компиляции Необходимо подчеркнуть, что никаких изменений с самим объектом не происходит, ограничение порождается используемым способом доступа к этому объекту - переменной типаParent.
Чтобы показать, что объект не потерял никаких свойств, произведем следующее обращение:
((Child)p).newChildMethodO;
Здесь вначале проводится явное сужение к типу Child. Во время исполнения программы JVM проверит, совместим ли тип объекта, на который ссылается переменная р, с типом Child. В нашем случае это именно так. В результате получается ссылка типа Child, поэтому становится допустимым вызов метода newChildMethodO, который вызывается у объекта. созданного в предыдущей строке.
Обратим внимание на важный частный случай - переменная типа Object может ссылаться на объекты любого типа.
В дальнейшем, с изучением новых типов (абстрактных классов, интерфейсов, массивов) этот список будет продолжаться, а пока коротко обобщим то, что было рассмотрено в данном разделе.
Табл. 7.2. Тип переменной и тип ее значения.
Заключение
в этой лекции были рассмотрены правила работы с типами данных в строго типизированном языке Java. Поскольку компилятор строго отслеживает тип каждой переменной и каждого выражения, в случае изменения этого типа необходимо четко понимать, какие действия допустимы, а какие нет, с точки зрения компилятора и виртуальной машины.
Были рассмотрены все виды приведения типов в Java, то есть переход (УГОДНОГО типа к другому. Они разбиваются на 7 групп, начиная с тождественного и заканчивая запрещенными. Основные 4 вида определяются сужающими или расширяющими переходами между простыми или ссылочными типами. Важно помнить, что при явном сужении числовых типов старшие биты просто отбрасываются, что порой приводит к неожиданному результату. Что касается преобразования ссылочных значений, то здесь Действует правило — преобразование никогда не порождает новых и не исцеляет существующих объектов. Меняется лишь способ работы с ними. 7 Особенным в Java является преобразование к строке.
Затем были рассмотрены все ситуации в программе, где могут происходить преобразования типов. Прежде всего, это присвоение значений, Когда преобразование зачастую происходит незаметно для программиста, вызов метода во многом похож на инициализацию. Явное приведение позволяет осуществить желаемый переход в том случае, когда компилятор ей позволяет сделать это неявно. Преобразование при выполнении числовых операций оказывает существенное влияние на результат.
В заключение была рассмотрена связь между типом переменной и типом ее значения.
Вопросы для самоконтроля:
Виды приведений
Тождественное преобразование
Преобразование примитивных типов (расширение и сужение)
Преобразование ссылочных типов (расширение и сужение)
Преобразование к строке
Запрещенные преобразования
Применение приведений
Присвоение значений
Вызов метода
Явное приведение
Оператор конкатенации строк
Числовое расширение
Унарное числовое расширение
Бинарное числовое расширение
Тип переменной и тип ее значения
Рекомендуемая литература:
И.Ю.Баженова Язык программирования Java.- АО "Диалог-МИФИ", 1997
Джон Родли Создание Java-апплетов.- The Coriolis Group,Inc.,1996, Издательство НИПФ "ДиаСофт Лтд.",1996
Майкл Томас, Пратик Пател, Алан Хадсон, Доналд Болл(мл.) Секреты программирования для Internet на Java.- Ventana Press, Ventana Communications Group, U.S.A.,1996, Издательство"Питер Пресс", 1997
Аарон И.Волш Основы программирования на Java для World Wide Web.- IDG Books Worldwide,Inc.,1996, Издательство "Диалектика",1996
Кен Арнольд, Джеймс Гослинг Язык программирования Java.- Addison-Wesley Longman,U.S.A.,1996, Издательство "Питер-Пресс", 1997
Нейл Бартлетт, Алекс Лесли, Стив Симкин Программирование на Java. Путеводитель.- The Coriolis Group,Inc.,1996, Издательство НИПФ "ДиаСофт Лтд.",1996
Крис Джамса Библиотека программиста Java.- Jamsa Press, 1996, ООО "Попурри", 1996
