Типы с плавающей точкой
Числа с плавающей точкой (иногда их называют действительными числами) применяются при вычислении выражений, в которых требуется точность до десятичного знака. Например, это может быть вычисление квадратного корня, значений синуса, косинуса и т.п. Существует два типа с плавающей точкой: float и double, которые представляют числа одинарной и двойной точности.
Слово «плавающая» означает, что десятичная точка может располагаться в любом месте (она «плавает»). Вот коты плавать не особенно любят, поэтому они не float и не double.
Тип float
Тип float определяет значение одинарной точности, которое занимает 32 бит. Переменные данного типа удобны, когда требуется дробная часть без особой точности, например, для денежных сумм.
Рекомендуется добавлять символ F или f для обозначения этого типа, иначе число будет считаться типом double.
Конвертируем из строки.
Класс Float является оболочкой для данного типа. Без необходимости не используйте в Android класс Float.
Также есть специальный класс BigDecimal для проведения арифметических действий повышенной точности (финансовые расчёты).
Тип double
Тип double обеспечивает двойную точность, что видно из его названия (double — двойная). Занимает 64 бит для хранения значений. Многие математические функции возвращают значения типа double. Кстати, современные процессоры оптимизированы под вычисления значений двойной точности, поэтому они предпочтительнее, чем тип float.
Тип double содержит не только числа, но и слова. Сейчас вам докажу. Разделим число типа double на ноль. Ошибки не произойдёт.
Пример вернёт значение Infinity (Бесконечность). Если разделить отрицательное число на ноль, то вернётся -Infinity.
А что произойдёт, если сложить две бесконечности? Если рассуждать логически, то сломается интернет, наступит конец света или можно вызвать Волдеморта. Я долго не решался, но потом набрался храбрости и попробовал.
Вернулось ещё одно слово — NaN. Что это вообще? Может должно вернуться Nyan — ну вы знаете, это странный котик, который летит бесконечно в космосе, оставляя за собой шлейф из радуги.
Умножать две бесконечности я побоялся. И вам не советую.
Класс Double является оболочкой для данного типа. Без необходимости не используйте в Android класс Double.
Конвертация double в строку
При работе с числами double следует держать ухо востро. Рассмотрим пример конвертации трёх чисел.
Первые два числа нормально преобразовались, а вот третье число преобразовалось в строку в странном виде (на самом деле это научное представление числа). И это может источником проблемы при передаче строки куда-нибудь, например, на сервер. Если сервер не ожидает от вас такой подлости, то будет генерировать ошибки из-за странной записи. Нужно найти другие способы конвертации.
Первый способ — используем String.format().
Последний пример самый подходящий для нас, но вам нужно знать, сколько знаков идёт после десятичной точки. Остальные два пригодятся, если число можно округлить.
Второй способ — метод Double.toString(). У меня метод превратил число в «непонятную» строку. А у некоторых этот пример возвращал строку в нормальном виде. Не заслуживает доверия.
Третий способ — добавить пустую строку. В Android не помогло, хотя тоже утверждается, что у кого-то выводится в нормальном виде. Врут, наверное.
Четвёртый экзотический способ, которым редко пользуются — DecimalFormat.
Приоритеты операций
Все операции вычисляются слева направо (сначала вычисляется левый операнд, затем правый и затем сама операций, кроме операции присваивания. Операция присваивания вычисляется справа налево.
Вычисления производятся в соответствии с таблицей приоритетов операций, приведённой ниже. Операция, находящаяся выше в таблице, имеет более высокий приоритет, чем операция, находящаяся ниже, и вычиляется раньше. Операции, находящиеся на одной строке, имеют одинаковый приоритет. Если в одном выражении находится несколько разных операций, то сначала вычисляется результат операции с наивысшим приоритетом. Можно использовать скобки для указания того, что сначала нужно вычислить эту часть выражения.
Пример 1:
Java
int z = 200 * (3 + 4);
| 1 | intz=200*(3+4); |
Последовательность вычисляения такая:
- 3+4 = 7
- 200 * 7 = 1 400
- z = 1 400
Пример 2:
Java
int x;
int y;
int z = x = y = 10000 + 20000 >> 1 + 3 * 2;
|
1 |
intx; inty; intz=x=y=10000+20000>>1+3*2; |
Последовательность вычисления такая:
- 10 000 + 20 000 = 30 000 (Присвоение вычисляется справа налево, поэтому сначала смотрится
y=10000+20000>>1+3*2 , и вычисляется правая часть. В правой части (
10000+20000>>1+3*2 ) вычисление идёт слева направо, и берётся
10000+20000 (выбирается среди
10000+20000 ,
20000>>1 ,
1+3 и
3*2 ), которое вычисляется перед сдвигом, так как у сложения приоритет выше.) - 3 * 2 = 6 (В выражении
30000>>1+3*2 вычисление идёт слева направо, и выбирается умножение(среди
30000>>1 ,
1+3 и
3*2 ), так как у него приоритет выше, что означает, что сложение будет выполнено раньше.) - 1 + 6 = 7 (В выражении
30000>>1+6 вычисление идёт слева направо и сложение вычисляется раньше сдвига, так как приоритет у сложения выше.) - 30 000 >> 7 = 234 (0b00…111010100110000 сдвигаем на 7 бит вправо и получаем 0b00…0011101010)
- y = 234
- x = 234
- z = 234
Таблица приоритетов операций
| Группа операций | Приоритет |
|---|---|
| Группировка | |
| Доступ к члену | |
| постфиксные | |
| унарные | |
| мультипликативные | |
| аддитивные | |
| сдвиги | |
| сравнения | |
| равенства | |
| бинарный И | |
| бинарный исключающее ИЛИ | |
| бинарный ИЛИ | |
| логический И | |
| логический ИЛИ | |
| тернарный | |
| лямбда | |
| присваивания |
Цикл статей «Учебник Java 8».
Следующая статья — «Java 8 выражения, инструкции и блоки».
Предыдущая статья — «Переменные в Java 8».
Абстрактные методы и классы
Если класс объявлен с ключевым словом
abstract , то он называется абстрактным классом. Он может иметь, а может и не иметь абстрактных методов.
Monster.java
Java
abstract class Monster {
}
|
1 |
abstractclassMonster{ } |
Абстрактным методом называется метод, объявленный с ключевым словом
abstract и не имеющий тела метода.
Java
abstract void myAbstractMethod(int myParam1, double myParam2);
| 1 | abstractvoidmyAbstractMethod(intmyParam1,doublemyParam2); |
Если в классе есть абстрактные методы, то он ДОЛЖЕН быть объявлен абстрактным.
Нельзя создать экземпляр абстрактного класса, но можно указать абстрактный класс в качестве базового класса.
Дочерний класс от абстрактного класса должен либо дать реализацию всем его абстрактным методам, либо сам быть абстрактным классом.
Абстрактные классы очень похожи на интерфейсы, но абстрактные классы могут иметь поля экземпляров и могут иметь методы с модификатором доступа отличным от
public. Также вы можете наследовать свой класс только от одного другого класса, но вы можете реализовать любое количество интерфейсов.
Выбрать между абстрактным классом и интерфейсом бывает довольно сложно. Старайтесь руководствоваться правилами, описанными ниже.
Используйте абстрактные классы, если:
- Вы хотите использовать общий код в нескольких близко связанных классах.
- Вы ожидаете, что классы, которые будут наследоваться от вашего абстрактного класса, имеют большое количество общих полей или требуют использования модификаторов доступа отличных от
public. - Вам нужно объявить поля экземпляров или класса, а не только константы.
Используйте интерфейсы в следующих ситуациях:
Вы ожидаете, что интерфейс будут реализовывать не связанные друг с другом классы
Интерфейсы
Comparable и
Cloneable , например, реализует очень большое количество совершенно разных классов.
Вы хотите указать поведение определённого типа, но вам абсолютно не важно, кто будет реализовывать это поведение.
Вам нужно множественное наследование типов.. Для примера абстрактного класса представьте ситуацию, что вам нужно реализовать несколько различных видов монстров:
Goblin ,
Hobgoblin ,
Orc ,
Gremlin и
Genie
Каждый из эти монстров имеет свои различные особенности, которые будут реализовываться в соответствующем классе, но все эти монстры будут уметь ходить и иметь координаты в пространстве, и у каждого из них будет уровень здоровья. В этом случае можно заложить умение ходить, координаты и уровень здоровья в базовом классе
Monster, который сделать абстрактным, и в котором объявить абстрактные методы для управления повадками и прочими вещами, реализации которых будут в соответствующих дочерних классах
Для примера абстрактного класса представьте ситуацию, что вам нужно реализовать несколько различных видов монстров:
Goblin ,
Hobgoblin ,
Orc ,
Gremlin и
Genie. Каждый из эти монстров имеет свои различные особенности, которые будут реализовываться в соответствующем классе, но все эти монстры будут уметь ходить и иметь координаты в пространстве, и у каждого из них будет уровень здоровья. В этом случае можно заложить умение ходить, координаты и уровень здоровья в базовом классе
Monster, который сделать абстрактным, и в котором объявить абстрактные методы для управления повадками и прочими вещами, реализации которых будут в соответствующих дочерних классах.
Цикл статей «Учебник Java 8».
Следующая статья — «Java 8 перечисления».
Предыдущая статья — «Java 8 интерфейсы».
Конвертировать с использованием StringBuffer или StringBuilder
StringBuilder и StringBuffer – это классы, используемые для объединения нескольких значений в одну строку. StringBuffer является потокобезопасным, но медленным, тогда как StringBuilder не является поточно-ориентированным, но работает быстрее.
Пример 1
class Method5
{
public static void main(String args[])
{
int number1 = -1234;
StringBuilder sb = new StringBuilder();
sb.append(number1);
String str1 = sb.toString();
System.out.println("With StringBuilder method: string = " + str1);
StringBuffer SB = new StringBuffer();
SB.append(number1);
String str2 = SB.toString();
System.out.println("With StringBuffer method: string = " + str2);
}
}
Вывод
With StringBuilder method: string = -1234 With StringBuffer method: string = -1234
Объект StringBuilder представляет объект String, который можно изменять и обрабатывать как массив с последовательностью символов. Чтобы добавить новый аргумент в конец строки, экземпляр StringBuilder реализует метод append().
Пример 2
class Method6
{
public static void main(String args[])
{
String str1 = new StringBuilder().append(1234).toString();
System.out.println("With StringBuilder method: string = " + str1);
String str2 = new StringBuffer().append(1234).toString();
System.out.println("With StringBuffer method: string = " + str2);
}
}
Вывод
With StringBuilder method: string = -1234 With StringBuffer method: string = -1234
Наиболее важным является вызов метода toString(), чтобы получить строковое представление данных.
3 ответа
Лучший ответ
Что на самом деле происходит в вашем первом примере, так это то, что вычисляется , результат равен , затем он неявно приводится к и передается в . В основном это:
Как видите, это бесполезно! Также обратите внимание, что автоматическая распаковка автоматически преобразует в , и поэтому также не имеет смысла. Актерский состав — это правильный подход:
Актерский состав — это правильный подход:
Что, если вы используете вместо , эквивалентно:
Между прочим, цель состоит в том, чтобы просто дать вам способ явно поместить и преобразовать его в , если вам нужно. Цель противоположная. Ни то, ни другое не подходят для вашего сценария. (В целом это относится ко всем методам / в примитивных классах-оболочках.)
Кстати, чтобы снизить риск потери точности (не большой риск в вашем случае, но в целом), как правило, лучше сделать следующее, чем:
Этот тест завершится неудачно при определенных значениях (например, не то, что вы ожидаете), становится гарантированным, поскольку мантисса с основанием 2 для превышает диапазон мантиссы . Еще один простой тест:
Выход:
Обратите внимание на последнюю цифру. Эта опасность существует каждый раз, когда вы конвертируете целое число в двойное, в том числе в моих примерах выше — однако это стоит отметить, потому что передача в в моем мнение, может застать одного врасплох больше, чем других
Эта опасность существует каждый раз, когда вы конвертируете целое число в двойное, в том числе в моих примерах выше — однако это стоит отметить, потому что передача в в моем мнение, может застать одного врасплох больше, чем других.
4
Jason C
8 Авг 2014 в 16:48
Я написал следующие 2 метода:
Как видите, это упрощенная версия вашего кода; Я сделал это, чтобы эксперимент был чище.
Теперь я скомпилировал код, а затем распечатал байт-код, используя :
Как мы видим, код двух методов похож, но во втором случае у нас есть (как и ожидалось) вызовы , а затем .
Итак, кажется, что если у вас нет особых причин, вам просто нужно использовать кастинг. Он короче, понятнее и дешевле с точки зрения использования процессора.
-1
AlexR
5 Авг 2014 в 07:27
Я бы пошел
Но если вы не проделаете это 1000 раз в жестком цикле, это не имеет значения. Делайте то, что вам кажется ясным.
Некоторые утверждают, что «нет Double.valueOf (long)». Что ж, Java ведет себя так, как будто существует . делает именно то, что, по вашему мнению, он должен делать. В вашем коде, если тест не проводился годами, будет делать именно то, что вы думали. Я бы сказал, что Double.valueOf (long) действительно существует. Этого просто нет в Javadocs. Если я напишу , этого не существует?
Я согласен с другими здесь, что Double.valueOf (сейчас — тогда) .doubleValue () глупо, но его следует избегать, потому что он добавляет путаницы, а не потому, что он «бесполезен». С появлением автобокса и распаковки многие методы бесполезны , за исключением, возможно, того, чтобы прояснить ситуацию. Если вы думаете, что явный Double делает вещи более ясными (в этом примере я думаю, что нет, но ваш опыт может отличаться), вам следует написать код таким образом.
Например, я все еще часто использую «ненужное» , чтобы напомнить себе и другим программистам, что в противном случае произойдет автоматическая распаковка и может возникнуть таинственный NPE .
-1
Jason C
8 Авг 2014 в 16:53
Методы преобразования
4.1. Преобразование Между Примитивными Типами
Простой способ преобразования примитивов, чтобы избежать преобразования с потерями,-это понижение; другими словами, приведение типа большего размера к типу меньшего размера. Следовательно, это также называется сужением примитивного преобразования.
Например, давайте преобразуем длинное число в короткое с помощью понижающей передачи
long longNum = 24; short shortNum = (short) longNum; assertEquals(24, shortNum);
Аналогично, давайте преобразуем double в int :
double doubleNum = 15.6; int integerNum = (int) doubleNum; assertEquals(15, integerNum);
Однако следует отметить, что преобразование типа большого размера со слишком большими или слишком маленькими значениями в тип меньшего размера с помощью понижения может привести к неожиданным значениям.
Давайте преобразуем длинные значения за пределами диапазона короткие :
long largeLongNum = 32768; short minShortNum = (short) largeLongNum; assertEquals(-32768, minShortNum); long smallLongNum = -32769; short maxShortNum = (short) smallLongNum; assertEquals(32767, maxShortNum);
Если мы внимательно проанализируем конверсию, то увидим, что это не ожидаемые значения.
Другими словами, когда Java достигает наибольшего значения типа малого размера при преобразовании из типа большого размера, следующее число является наименьшим значением типа малого размера и наоборот.
Давайте разберемся в этом на примерах. Когда большое длинное число со значением 32768 преобразуется в короткое , значение короткое число 1 равно -32768 . Поскольку максимальное значение short равно 32767, поэтому Java переходит к следующему минимальному значению short.
Аналогично, когда маленькое длинное число преобразуется в короткое . Значение short Num2 равно 32767, поскольку Java переходит к следующему максимальному значению short .
Кроме того, давайте посмотрим, что произойдет, когда мы преобразуем максимальные и минимальные значения a long в int :
long maxLong = Long.MAX_VALUE; int minInt = (int) maxLong; assertEquals(-1, minInt); long minLong = Long.MIN_VALUE; int maxInt = (int) minLong; assertEquals(0, maxInt);
4.2. Преобразование между объектами-оболочками и примитивными типами
Чтобы напрямую преобразовать объект-оболочку в примитив, мы можем использовать различные методы в классах-оболочках, такие как int Value () , shortValue() и longValue() . Это называется распаковка .
Например, давайте преобразуем объект Float в объект long :
Float floatNum = 17.564f; long longNum = floatNum.longValue(); assertEquals(17, longNum);
Кроме того, если мы посмотрим на реализацию long Value или аналогичных методов, мы найдем применение сужающего примитивного преобразования:
public long longValue() {
return (long) value;
}
Однако иногда следует избегать сужения примитивного преобразования, чтобы сохранить ценную информацию:
Double doubleNum = 15.9999; long longNum = doubleNum.longValue(); assertEquals(15, longNum);
После преобразования значение long Num будет равно 15. Однако двойное число равно 15.9999, что очень близко к 16.
Вместо этого мы можем использовать Math.round() для преобразования в ближайшее целое число:
Double doubleNum = 15.9999; long longNum = Math.round(doubleNum); assertEquals(16, longNum);
4.3. Преобразование Между Объектами-Оболочками
Для этого давайте воспользуемся уже рассмотренными методами преобразования.
Сначала мы преобразуем объект-оболочку в примитивное значение, опустим его и преобразуем в другой объект-оболочку . Другими словами, мы будем выполнять техники распаковки, даункастинга и бокса.
Например, давайте преобразуем объект Double в объект Integer :
Double doubleNum = 10.3; double dbl = doubleNum.doubleValue(); // unboxing int intgr = (int) dbl; // downcasting Integer intNum = Integer.valueOf(intgr); assertEquals(Integer.valueOf(10), intNum);
Наконец, мы используем Integer . valueOf() для преобразования примитивного типа int в Целое число объект. Этот тип преобразования называется boxing .
Логические И и ИЛИ
Логическое И
&& и Логическое ИЛИ
|| ведут себя вполне ожидаемо для логического И или логического ИЛИ:
Java
boolean b1 = true && true; //true
boolean b2 = true && false; //false
boolean b3 = true || false; // true
boolean b4 = false || false; //false
System.out.println(b1);
System.out.println(b2);
System.out.println(b3);
System.out.println(b4);
|
1 |
booleanb1=true&&true;//true booleanb2=true&&false;//false booleanb3=true||false;// true booleanb4=false||false;//false System.out.println(b1); System.out.println(b2); System.out.println(b3); System.out.println(b4); |
Логическое И
&& вычисляет свой правый операнд только в том случае, если левый равен
true. Если левый операнд равен
false, то сразу возвращается
false. Логическое ИЛИ
|| вычисляет правый операнд только в том случае, если левый равен
false. Если левый операнд равен
true, то сразу возвращается
true. Эти два правила сокращения вычислений позволяют сразу откинуть последующие вычисления, если результат всего выражения уже известен. Это можно использовать для проверки на
null перед проверкой результата какого-либо метода объекта (будет описано в дальнейшем):
Java
if (obj != null && obj.method1()) { // obj.method1() будет вызывать только
// если проверка obj!= null вернула true.
}
|
1 |
if(obj!=null&&obj.method1()){// obj.method1() будет вызывать только // если проверка obj!= null вернула true. } |
Приведение типов Java
Несмотря на все удобство автоматического преобразования типов, оно не в состоянии удовлетворить все насущные потребности. Например, что делать, если значение типа нужно присвоить переменной типа ? Это преобразование не будет выполняться автоматически, поскольку длина типа меньше, чем у типа . Иногда этот вид преобразования называется сужающим преобразованием, поскольку значение явно сужается, чтобы уместиться в целевом типе данных.
Чтобы выполнить преобразование двух несовместимых типов данных, нужно воспользоваться приведением типов. Приведение — это всего лишь явное преобразование типов. Общая форма приведения типов имеет следующий вид:
где параметр обозначает тип, в который нужно преобразовать указанное значение.
Например, в следующем фрагменте кода тип приводится к типу
Рассмотрим пример преобразования значений с плавающей точкой в целые числа. В этом примере дробная часть значения с плавающей точкой просто отбрасывается (операция усечения):
При приведении более емкого целого типа к менее емкому старшие биты просто отбрасываются:
При приведении более емкого значения с плавающей точкой в целое число происходит усечение и отбрасывание старших битов:
Использование ключевого слова super
Если ваш метод переопределяет метод базового класса, то вы не можете вызвать метод базового класса напрямую по имени. Вам нужно использовать ключевое слово
super .
Если ваш класс определяет поле с тем же именем, что и поле в родительском классе,пусть даже с другим типом, то это поле скрывает (hide) поле родительского класса. В этом случае вы не можете напрямую обратиться к полю родительского класса по имени. Если всё же нужно обратиться к этому полю родительского класса, то нужно использовать ключевое слово
super .
Пример:
Main.java
Java
class Monster {
double gold = 10.0;
void walk() {
System.out.println(«Monster walk.»);
}
}
class Goblin extends Monster {
// Это скрывает поле gold класса Monster.
double gold = 20.0;
// Это переопределяет метод walk класса Monster.
void walk() {
System.out.println(«Goblin walk»);
System.out.println(«Goblin gold = » + gold);
// Мы можем обратиться к скрытому полю
// родительского класса
System.out.println(«Monster gold = » + super.gold);
// Мы можем вызвать переопределённый метод родительского класса.
super.walk();
}
}
class Main {
public static void main(String[] args) {
Goblin goblin = new Goblin();
goblin.walk();
}
}
|
1 |
classMonster{ doublegold=10.0; voidwalk(){ System.out.println(«Monster walk.»); } } classGoblinextendsMonster{ // Это скрывает поле gold класса Monster. doublegold=20.0; // Это переопределяет метод walk класса Monster. voidwalk(){ System.out.println(«Goblin walk»); System.out.println(«Goblin gold = «+gold); // Мы можем обратиться к скрытому полю // родительского класса System.out.println(«Monster gold = «+super.gold); // Мы можем вызвать переопределённый метод родительского класса. super.walk(); } } classMain{ publicstaticvoidmain(Stringargs){ Goblin goblin=newGoblin(); goblin.walk(); } } |
Результат в консоли:
Goblin walk
Goblin gold = 20.0
Monster gold = 10.0
Monster walk.
|
1 |
Goblin walk Goblin gold = 20.0 Monster gold = 10.0 Monster walk. |
С помощью ключевого слова
super можно вызвать конструктор родительского класса в классе потомке:
Main.java
Java
class Monster {
private int ammo;
private double gold;
private double health;
Monster(int ammo, double gold, double health) {
this.ammo = ammo;
this.gold = gold;
this.health = health;
}
}
class Goblin extends Monster {
private int trunks;
Goblin(int ammo, double gold, double health, int trunks) {
super(ammo, gold, health);
this.trunks = trunks;
// …
}
}
|
1 |
classMonster{ privateintammo; privatedoublegold; privatedoublehealth; Monster(intammo,doublegold,doublehealth){ this.ammo=ammo; this.gold=gold; this.health=health; } classGoblinextendsMonster{ privateinttrunks; Goblin(intammo,doublegold,doublehealth,inttrunks){ super(ammo,gold,health); this.trunks=trunks; // … } } |
Вызов конструктора суперкласса должен быть первой инструкцией в конструкторе дочернего класса. Можно вызвать конструктор суперкласса без параметров (конструктор по умолчанию):
Java
super()
| 1 | super() |
Если вы не вставили ни одного явного вызова конструктора родительского класса, то компилятор Java автоматически добавит вызов конструктора родительского класса без параметров (конструктора по умолчанию). Если конструктор родительского класса без параметров недоступен из-за модификатора доступа, или конструктора без параметров нет в родительском классе, то возникнет ошибка компиляции.
При создании экземпляра любого объекта происходит цепочка вызовов конструкторов от конструктора создаваемого объекта до конструктора класса
Object . Это называется цепочкой вызова конструкторов (constructor chaining).
Явное
В этом случае, если вы хотите присвоить значение большего типа данных меньшему типу данных, вы можете выполнить явное приведение или сужение типов. Это полезно для несовместимых типов данных, где автоматическое преобразование невозможно.
Давайте разберемся с этим на примере.
//Java program to illustrate explicit type conversion
public class Narrowing
{
public static void main(String[] args)
{
double d = 200.06;
//explicit type casting
long l = (long)d;
//explicit type casting
int i = (int)l;
System.out.println("Double Data type value "+d);
//fractional part lost
System.out.println("Long Data type value "+l);
//fractional part lost
System.out.println("Int Data type value "+i);
}
}
Вывод:
Double Data type value 200.06 Long Data type value 200 Int Data type value 200
Явное приведение в выражениях
Когда вы вычисляете выражения, выходные данные автоматически обновляются до большего типа данных операнда. Но если вы сохраните этот результат в каком-либо меньшем типе данных, он генерирует ошибку времени компиляции, из-за которой нам нужно набрать приведение вывода.
Пример:
//Java program to illustrate type casting int to byte
public class ExplicitTest {
public static void main(String args[])
{
byte b = 70;
//type casting int to byte
b = (byte)(b * 2);
System.out.println(b);
}
}
Вывод:
Автоматическое преобразование типов Java
Рассмотрим сначала автоматическое преобразование. Если оба типа совместимы, их преобразование будет выполнено в Java автоматически. Например, значение типа всегда можно присвоить переменной типа int, как это показано в предыдущем примере.
Для автоматического преобразования типа должно выполняться два условия:
- оба типа должны быть совместимы
- длина целевого типа должна быть больше длины исходного типа
В этом случае происходит преобразование с расширением.
Следующая схема показывает расширяющее преобразование в Java:
Сплошные линии обозначают преобразования, выполняемые без потери данных. Штриховые линии говорят о том, что при преобразовании может произойти потеря точности.
Например, тип данных всегда достаточно велик, чтобы хранить все допустимые значения типа , поэтому никакие операторы явного приведения типов в данном случае не требуются. С точки зрения расширяющего преобразования числовые типы данных, в том числе целочисленные и с плавающей точкой, совместимы друг с другом. В то же время не существует автоматических преобразований числовых типов в тип или . Типы и также не совместимы друг с другом.
Стоит немного пояснить почему, к примеру тип не преобразуется автоматически (не явно) в тип char, хотя тип имеет ширину 8 бит, а — 16. То же самое касается и преобразования типа в . Это происходит потому, что и знаковые типы данных, а беззнаковый. Поэтому в данном случае требуется использовать явное приведение типов, поскольку компилятору надо явно указать, что вы знаете чего хотите и как будет обрабатываться знаковый бит типов и при преобразовании к типу .
Поведение величины типа char в большинстве случаев совпадает с поведением величины целого типа, следовательно, значение типа можно использовать везде, где требуются значения или . Однако напомним, что тип не имеет знака, поэтому он ведет себя отлично от типа , несмотря на то что диапазон обоих типов равен 16 бит.
Основы класса Integer
Поскольку класс Integer имеет широкую функциональность, мы решили разделить данное руководство на разделы.
Как создать экземпляр класса Integer
Есть два способа создать экземпляр класса Integer. Первый способ – использовать ключевое слово new:
Integer secondInteger = new Integer(100);
Второй способ создать — использовать функцию автоупаковки (autoboxing) языка Java, которая конвертирует примитивный тип данных в соответствующий класс-обёртку:
Integer sampleInteger = 100;
Тест на равенство объектов Integer
Объекты Integer являются обёрткой для примитивного типа int. Поскольку они являются объектами, то оператор == не будет работать. Рассмотрим приведенный ниже отрывок кода:
Integer firstInteger = 100; Integer secondInteger = new Integer(100); System.out.println(firstInteger==secondInteger);
Поскольку мы имеем дело с объектами Integer, оператор == больше не применим. Как же провести сравнение двух Java объектов Integer? Рассмотрим приведенный ниже отрывок кода, демонстрирующий это:
Java-программа для проверки объектов Integer на равенство
package com.javatutorialhq.java.examples;
/*
* Пример программы для проверки объектов Integer на равенство
*/
public class IntegerTestEquality {
public static void main(String[] args) {
// создаём объекты Integer
Integer firstInteger = 100;
Integer secondInteger = new Integer(100);
// проверка на равенство
System.out.println(firstInteger.equals(secondInteger));
}
}
Максимальное и минимальное значения Integer
Чтобы найти максимальное и минимальное значения Integer, мы обратимся к двум его полям. Максимальное значение объекта Integer (2147483647) может быть найдено с помощью вызова Integer.MAX_VALUE, а минимальное значение Integer (-2147483648) – через обращение к Integer.MIN_VALUE.
Рассмотрим метод parseInt(String s), который принимает строку в качестве аргумента и конвертирует её в объект Integer. Если мы передадим строковое значение, которое имеет целочисленный эквивалент, превышающее максимальное значение в Integer.MAX_VALUE? Грубым примером такого сценария может служить приведенный ниже код:
Integer intValue = Integer.parseInt("2147483648");
Мы передали в метод parseInt аргумент, который на 1 больше максимального значения. Поэтому если мы попытаемся выполнить этот отрывок кода, компилятор выдаст исключение NumberFormatException:
Exception in thread "main" java.lang.NumberFormatException: For input string: "2147483648"
at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
at java.lang.Integer.parseInt(Integer.java:587)
at java.lang.Integer.parseInt(Integer.java:615)
at com.javatutorialhq.java.examples.IntegerTestEquality.main(IntegerTestEquality.java:12)
Как использовать статичные методы класса Integer
Большинство методов класса Integer статичные, поэтому имеет смысл разобраться, как получить доступ к ним. Не статичные методы используются так:
Integer intValue = Integer.parseInt("2147");
System.out.println(intValue.byteValue());
Статические методы не должны использоваться таким образом, а должны вызываться так как показано ниже:
System.out.println(Integer.max(1243, 1245));
Нестатические методы вызываются через переменная.метод. Статичные вызываются через Integer.метод(аргументы…).
