В данном уроке мы расскажем вам о небольшой головной боли программистов — приведении типов. Что такое приведение типов? Это любое преобразование типа данных.
Например:
Int b = 3;
double a = 1.0 * b;//преобразование типов
a = (double)b;//преобразование типов
Таким образом можно увидеть два способа изменения типа:
К каким типам можно приводить? Можно приводить к таким типам данных, которые находятся в одной иерархии. Допустим можно привести целое число к вещественному и наоборот. Можно привести класс Student к классу User и так далее. Очевидно, что приводить строку к числу бесполезно, так как это разные объекты. В таком случае обычно пользуются специальными операциями.
У более менее опытных пользователей может возникнуть следующий вопрос:
Int b = 3;
double a = b;//преобразование типов 1
b = (int) a;//преобразование типов 2
Почему типу данных double можно присваивать тип данных int и компилятор не выдаст ошибку, а для того, чтобы double привести в int нужно явно указать тип? Оказывается безопасные преобразования, например от int к double или от сына к родителю называют расширяющими, т.е мы даем типу данных с более низкими возможностями расширится, например целому типу данных, даем возможность становится вещественным, расширяя его область применения. Преобразование называется расширяющим, если тип данных к которому мы приводим включает в себя тип данных который мы хотим привести для базовых типов.
Сужающие преобразования всегда связаны с некоторой потерей информации, например преобразовывая от double к int мы теряем все значения после запятой, что вызывает опасения у компьютера и только явное указание типа данных может уверить его, что мы делаем это преобразование в здравом уме и твердой памяти.
Рассмотрим еще раз пример с фигурами:
Public class Shape {
}
public class Square extends Shape {
}
Square square;
Shape shape = square;//расширяющие преобразование
square = shape;//сужающие преобразование
Казалось бы преобразовывая от сына к родителю мы наоборот сужаемся, а не расширяемся, в чем причина? А причина состоит в том, что на самом деле класс Square содержит всю информацию класса Shape и преобразовываясь от сына к отцу, мы только теряем информацию специфичную для сына, которая в данный момент может быть не важна, но преобразовываясь от Shape к Square мы можем получить такую ситуацию, что у нас просто нет данных, необходимой для работы класса, например у нас нет размера квадрата, если говорить о примере выше.
И в завершении урока рассмотрим оператор instanceof, он возвращает true если объект имеет заданный тип:
If(new Square() instanceof Shape){//false
Мы закончили нашу прошлую статью о на том, что я пообещал Вам рассказать, какие типы можно приводить и как это все делается. Давайте же приступим.
Приведение типов в арифметических выражениях выполняется автоматически.
byte->short->int->long->float->double
Если операнды a и b комбинируются бинарным оператором (ниже мы это обсудим), перед его исполнением оба операнда преобразуются в данные одного типа следующим образом:
Разрешенные преобразования типов
Сплошные линии показывают преобразование, выполненное без потери информации. Это преобразование выполняется неявно. Преобразования, когда может произойти потеря информации, называются каст (casting). Они показанные штриховыми линиями. Если к типу данных на рисунке нет линий, то такое преобразование невозможно. Преобразования с потерей информации нужно проводить очень внимательно. Так, как можно потерять значительную часть данных и при этом программа может работать правильно.
Для сужения каст необходимо сделать явным. Например: byte b = (byte)128; прикастили инт к байт типу.
Предлагаю сделать несколько примеров.
Вы могли немного не понять данный код, так как я еще не объяснил, что такое компилятор, константы и т.д. Далее по обучению я все расскажу, хотя должен был сделать это раньше. А сейчас я хочу описать, какими правилами должны обладать названия переменных.
И так, как в этой статье я затронул выражение бинарный оператор, то предлагаю рассмотреть и операторы в Java. Тем более, что теории не так и много.
Java имеет несколько типов операторов: простое присваивание, арифметическое, унарное, равноправное и реляционное, условное, сравнение типов, побитовое и битовое смещение.
Много умных слов, но очень просто все объяснит вот эта картинка:
На первых порах мы будем пользоваться побитовым сравнением, присваиванием, и постфиксными операторами. Другие операторы встречаются не так часто, поэтому мы рассмотрим только те, которыми будем пользоваться.
public class OperatorsInJava {
int a = 5 ;
int b = 6 ;
int sum = a + b;
int difference = a - b;
Приведение типов может быть явное и автоматическое.
При явном приведении типов сама операция приведения задается явным образом.
При автоматическом приведении типов нужно, чтобы выполнялись два условия:
Явное приведение типов позволяет осуществлять присвоение несовместимых типов. Общая форма явного приведения типов имеет вид:
(целевой_тип) значениецелевой_тип – это тип, в который нужно привести указанное значение .
Примеры явного приведения типов.
// явное приведение типов в выражениях byte b; int a; double d; float f; d = -39.9203; a = (int )d; // a = -39 f = (float )d; // f = -39.9203 b = (byte )d; // b = -39 d = 302930932; b = (byte )d; // b = -12 - урезание значения a = -27; b = (byte )a; // b = -27Пример 1 . Автоматическое приведение целочисленных типов.
// автоматическое приведение целочисленных типов int a; byte b; short sh; b = -23; a = b; // a = -23 - автоматическое приведение типов sh = -150; a = sh; // a = -150 long l = 200; // Ошибка: "Type mismatch: cannot convert from long to int" // a = l; l = b; // l = -23 l = sh; // l = -150 char c = "Z" ; a = c; // a = 90 - код символа "Z" boolean b1 = false ; //a = b1; - ошибка, типы несовместимыеПример 2 . Автоматическое приведение типов с плавающей запятой.
// автоматическое приведение типов с плавающей запятой float f; double d; f = 3.409033f; d = f; // d = 3.409033Пример 3 . Автоматическое приведение смешанных типов. Такой случай возможен, если переменной типа с плавающей запятой присваивается значение переменной целочисленного типа.
// автоматическое приведение смешанных типов float f; double d; a = 28; d = a; // d = 28.0 f = a; // f = 28.0 // Ошибка: Type mismatch: cannot convert from float to int // a = f;Автоматическое продвижение типов происходит в выражениях. При этом, значение, которое фигурируют в выражениях, автоматически продвигаются к типам с большими диапазонами значений.
При автоматическом продвижении типов в выражениях:
Вышеприведенный пример работает корректно, так как:
В вышеприведенном примере значения 1000 превышает диапазон значений типа byte. Сначала число 1000 приводится к типу int. Но результат
1000 / 20 = 50приводится к типу byte и может корректно поместиться в переменной b .
Если написать так:
byte b; b = 100000 / 20; // ошибка, так как результат не помещается в тип byteто выйдет ошибка компиляции с выводом сообщения:
В этом случае результат не помещается в тип byte:
100000 / 20 = 5000Тогда это число (5000) автоматически становится типом int и компилятор выдаст сообщение об ошибке.
Если сделать явное приведение типов:
byte b; b = (byte ) (100000 / 20); // b = -120то в этом случае результат 5000 типа int превращается в тип byte. Как известно, переменная типа int занимает 32 бита, а переменная типа byte занимает 8 бит. Значение переменной типа int урезается. И имеем то, что имеем (b = -120 ).
Вышеприведенные примеры относятся и к переменным типов short и char.
В вышеприведенном примере в выражении используется переменная d типа int . Поэтому компилятор выдаст сообщение об ошибке:
Type mismatch: cannot convert from int to byteЭто означает, что результат есть типа int (а не byte ) даже если значение помещается в диапазон значений типа byte. Поскольку в выражении используется переменная-операнд d типа int.
Если осуществить явное приведение типов, то результат будет корректным:
// продвижение типов в выражениях // byte -> int byte b; int d; d = 20; b = (byte )(1000 / d); // b = 50 - работает корректноПример продвижения типов из int в long. Если один из операндов есть типа long, то все выражение продвигается к типу long.
int d; long l; d = 10000 * 200; // работает, d = 2000000 // Ошибка! Type mismatch: cannot convert from long to int // d = 1L * 2L; - операнды 1L и 2L есть типа long l = 100; // ошибка, один из операндов есть типа long // d = l * 2;Как видно из примера, если один из операндов есть типа long , то все выражение становится типа long .
Java является строго типизированным языком программирования, а это означает, то что каждое выражение и каждая переменная имеет строго определенный тип уже на момент компиляции.
Виды приведений
В Java предусмотрено семь видом приведений:
byte b=3;
int a=b;
Следующие 19 преобразований являются расширяющими:
long a = 111111111111L;
float f=a;
a=(long)f; // () это как раз и есть операция преобразования типа
System.out.println(a); //результат 111111110656
Обратите внимание – сужение – означает, что переход осуществляется от боле емкого типа к менее емкому. При таком преобразовании есть риск потерять данные. Например, если число типа int было больше 127, то при приведении его к byte значения битов старше восьмого будут потеряны. В Java такое преобразование должно совершаться явным образом, т.е. программист в коде должен явно указать, то он намеревается осуществить такое преобразование и готов потерять данные.
Следующие 23 преобразования являются сужающими:
System.out.println((byte)383);
System.out.println((byte)384);
System.out.println((byte)-384);
Результатом будет:
127
-128
-128
Видно, что знаковый бит при сужении не оказал никакого влияния, так как был просто отброшен – результат приведения обратных чисел (384, -384) оказался одинаковым. Следовательно, может быть потеряно не только точное абсолютное значение, но и знак величины.
Это верно и для char:
char c=4000;
System.out.println((short)c);
Результат:
-25536
Преобразование ссылочных типов (расширение и сужение)
Преобразование объектных типов лучше всего иллюстрируется с помощью дерева наследования. Рассмотрим небольшой пример наследования:
class Parent {
int x;
}
class ChildY extends Parent {
int y;
}
class ChildZ extends Parent {
int z;
}
В каждом классе объявлено поле с уникальным именем. Будем рассматривать это поле как пример набора уникальных свойств, присущи некоторому объектному типу.
Объекты класса Parent обладают только одним полем x, а значит, только ссылки типа Parent могут ссылаться на такие объекты. Объекты класса ChildY обладают полем y и полем x, полученным по наследству от класса Parent. Стало быть, на такие объекты могут указывать ссылки типа ChildY или Parent. Пример:
Parent p = new ChildY();
Обратите внимание, что с помощью такой ссылки p можно обращаться лишь к полю x созданного объекта. Поле y недоступно, так как компилятор, проверяя корректность выражения p.y, не может предугадать, что ссылка p будет указывать на объект типа ChildY во время исполнения программы. Он анализирует лишь тип самой переменной, а она объявлена как Parent, но в этом классе нет поля y, что и вызовет ошибку компиляции.
Аналогично, объекты класса ChildZ обладают полем z и полем x, полученным по наследству от класса Parent. Значит, на такие объекты могут указывать ссылки типа ChildZ и Parent.
Таким образом, ссылки типа Parent могут указать на объект любого из трех рассматриваемых типов, а ссылки типа ChildY и ChildZ – только на объекты точно такого же типа. Теперь можно перейти к преобразования ссылочных типов на основе такого дерева наследования.
Расширение означает переход от более конкретного типа к менее конкретному, т.е. переход от детей к родителям. Подобно случаю с примитивными типами, этот переход производиться самой JVM при необходимости и «незаметен» для разработчика, то есть не требует никаких специальных преобразования.
Parent p1=new ChildY();
Parent p2=new ChildZ();
В обеих строках переменным типа Parent присваивается значение другого типа, а значит, происходит преобразование. Поскольку это расширение, оно производиться автоматически и всегда успешно.
Нужно заметить, что при подобном преобразовании с самим объектом ничего не происходит. Несмотря на то что, например, поле y класса ChildY теперь недоступно, это не значит, что оно исчезло. Такое существенно изменение объекта не возможно. Он был порожден от класса ChildY и сохраняет все его свойства. Изменился лишь тип ссылки, через которую идет обращение к объекту.
Обратный переход, то есть движение по дереву наследования вниз, к наследникам, является сужением. Например, для рассматриваемого случая, переход от ссылки типа Parent , которая может ссылаться на объекты трех классов, к ссылке типа ChildY, которая может ссылаться только на один класс из трех, очевидно, является сужением. Такой переход может оказаться невозможным. Если ссылка типа Parent ссылается на объект типа Parent или ChildZ, то переход к ChildY невозможен, так как в обоих случаях объект не обладает полем y, которое объявлено в классе ChildY. Поэтому при сужении разработчику необходимо явным образом указывать на то, что необходимо попытаться провести такое преобразование. JVM во время исполнения проверит корректность перехода. Если он возможен, преобразование будет проведено. Если же нет – возникнет ошибка (обычно ClassCastException).
Parent p=new ChildY();
ChildY cy = (ChildY)p; //верно
Parent p2=new ChildZ();
ChildY cy2 = (ChildY)p2; //ошибка
Чтобы проверить, возможен ли желаемый переход, можно воспользоваться оператором instanceof:
Parent p=new ChildY();
if (p instanceof ChildY) {
ChildY cy = (ChildY)p;
}
Parent p2=new ChildZ();
if (p2 instanceof ChildY) {
ChildY cy = (ChildY)p2;
}
Parent p3=new Parent();
if (p3 instanceof ChildY) {
ChildY cy = (ChildY)p3;
}
В данном примере ошибок не возникнет. Первое преобразование возможно, и оно будет осуществлено. Во втором и третьем случаях условия операторов if не сработают и следовательно некорректного перехода не будет.
Преобразование к строке
Любой тип может быть приведен к строке, т.е. к экземпляру класса String. Такое преобразование является исключительным в силу того, что охватывает абсолютно все типы.
Различные типы преобразуются к строке следующим образом:
Применение приведений
Ситуации применения преобразования типов могут быть сгруппированы следующим образом:
Часто возникает необходимость преобразования строк в значения других типов, таких как int или boolean, и наоборот. В соответствии с принятым соглашением ответственность за преобразование строки в значение другого типа возложена на соответствующий метод этого типа. Так, например, преобразование строки в величину типа int выполняет статический метод из состава класса-оболочки Integer. В следующей таблице указаны все типы, допускающие преобразование значений в строки и наоборот, и перечислены соответствующие методы.
ТИП Метод для преобразова- Метод для преобразования из строки
ния В строку
boolean String.valueOf(boolean) new.Boolean(String). booleanvalue()
byte String.valueOf(byte) Byte.parseByte(string, int)
short String.valueOf(short) Short.parseShort(string, int)
int String.valueOf(int) Integer.parseInteger(string, int)
long String.valueOf(long) Long.parseLong(String, int)
float String.valueOf(float) Float.parseFloat(String)
double String.valueOf(double) Double.parseDouble(String)
Для преобразования строки в значение Boolean необходимо создать объект Boolean и затем запросить его значение. Все остальные классы-оболочки содержат Соответствующие методы parse. Методы parse целочисленных типов существуют в двух перегруженных формах: первая, помимо строки, требует задания дополнительного аргумента типа int, представляющего основание системы счисления – от 2 до 32; вторая принимает только параметр строки и по умолчанию предполагает использование десятичной системы счисления. Во всех случаях, кроме Boolean, предполагается следующее: если строка представляет значение, которое не может быть корректно преобразовано в число соответствующего типа, выбрасывается исключение NumberFormatException. Класс Boolean удовлетворяет соглашению, в соответствии с которым любая строка-параметр, не равная “true” (без учета регистра символов), приводит к созданию объекта вооlеаn со значением false.
Методов, позволяющих преобразовать символы, которые представлены в одной из поддерживаемых языком форм (таких как \b, \uxxxx и т.д.), В значения типа char и наоборот, не существует. Чтобы получить объект String, содержащий единственный символ, достаточно вызвать метод String.valueOf, передав ему в качестве параметра соответствующее значение типа char.
Отсутствуют также и способы создания строковых представлений чисел, заданных в одном из поддерживаемых языком форматов – с ведущим нулем (О), обозначающим восьмеричное число, и префиксом Ох (или ОХ), служащим признаком шестнадцатеричной системы счисления. Напротив, в целочисленных классах-оболочках поддерживаются версии метода decode, способного преобразовать строки в числовые значения соответствующего типа и “понимающего”, что ведущий О обозначает восьмеричное число, а один из префиксов Ох ИЛИ Ох – шестнадцатеричное.
Любой прикладной класс способен обеспечить поддержку преобразований собственных объектов в строки и обратно, если в его объявлении будет соответствующим образом переопределен метод toString и предусмотрен специальный конструктор, создающий объект класса на основе строки, переданной в качестве параметра. В вашем распоряжении имеется также метод String.valueOf(Object obj), который возвращает либо строковый объект “null” (если значение obj равно null), либо результат работы метода obj.toString. Класс String содержит достаточное количество перегруженных версий метода valueOf, позволяющих преобразовать любое значение любого типа в объект String посредством простого вызова valueOf с передачей нужного аргумента.