Урок 21. Java автоупаковка, статический импорт, типы данных и кое-что еще

В этой статье из уроков Java для начинающих я объясню различные темы, которые еще не были рассмотрены в этой серии.

Статический импорт

В этом разделе я собираюсь обсудить статический импорт. В приведенном ниже коде мы имеем два импорта. Первый “импорт org.junit.Test;” используется для импорта класса и позволяет использовать краткое имя класса вместо его полного имени, включая пакет. Второй оператор импорта: “import static org.junit.Assert.*”, импортирует статические переменные и методы класса. Поскольку оператор заканчивается на ‘*’, он импортирует все статические функции и переменные в классе. Однако вы также можете импортировать только определенные функции или атрибуты в классе.

import org.junit.Test;
import static org.junit.Assert.*;

public class DemoTest {
	@Test
	public void shouldDemonstrateStaticImport() {
		assertTrue(true);
	}
}

В коде выше вы можете увидеть пример использования статических переменных и методов из класса без использования имени класса. В то время как обычно вам нужно было бы вызвать Assert.assertTrue, вместо этого вам просто нужно было вызвать assertTrue.

Обратите внимание, что если статический метод или переменная с одинаковым именем существуют в двух разных классах, то с помощью статического импорта можно импортировать только один метод. Для второго метода вам придется использовать полноценное имя, аналогичное обычному оператору импорта.

Типы данных и их значения по умолчанию

В следующем разделе статьи я собираюсь обсудить начальные значения по умолчанию для переменных экземпляра. Давайте посмотрим на все возможные значения переменных экземпляра по умолчанию в Java просто распечатав их:

public class DemoTest {
     private byte myByte;
     private short myShort;
     private int myInt;
     private long myLong;
     private float myFloat;
     private double myDouble;
     private Object myObject;
     private boolean myBoolean;
     private char myChar;

    @Test
    public void shouldDemonstrateDataTypeDefaultValues() {
        System.out.println("byte default value: " + myByte);
        System.out.println("short default value: " + myShort);
        System.out.println("int default value: " + myInt);
        System.out.println("long default value: " + myLong);
        System.out.println("float default value: " + myFloat);
        System.out.println("double default value: " + myDouble);
        System.out.println("Object default value: " + myObject);
        System.out.println("boolean default value: " + myBoolean);
        System.out.println("char default value: " + myChar);
        System.out.println("char default value as int: " + (int) myChar);
    }
}

Вывод:

byte default value: 0
short default value: 0
int default value: 0
long default value: 0
float default value: 0.0
double default value: 0.0
Object default value: null
boolean default value: false
char default value:
char default value as int: 0

Для всех типов чисел их значения по умолчанию равны нулю. Объекты по умолчанию имеют значение null, а логические значения - значение false. Вы можете задаться вопросом, почему значение char по умолчанию кажется пустым. Значение по умолчанию char на самом деле ‘\u0000’, которое известно как нулевой символ. Как вы можете видеть, нет никакого визуального представления этого персонажа. Однако если вы преобразуете значение char по умолчанию в int, оно будет напечатано как “0”.

Числовые типы

Далее мы рассмотрим различные числовые типы в Java более подробно.

Существует множество различных типов чисел, которые могут быть использованы в Java. Первые четыре типа чисел, которые я выделю, - это типы данных byte, short, int и long. Все четыре из них могут хранить только целочисленные значения. Однако они имеют различные диапазоны, как вы можете видеть в таблице в конце этого раздела. При нормальных обстоятельствах программисты используют int, потому что разница в пространстве памяти между типами чисел в наши дни относительно невелика. В некоторых случаях вам может понадобиться использовать long, если ваши числа слишком велики, чтобы их можно было хранить в виде int.

Float и double - это два типа чисел с плавающей запятой (точкой). Опять же, вы можете увидеть их диапазоны ниже. Если в коде есть десятичное значение, оно автоматически считается двойным по определению. Если вы хотите сохранить его в виде поплавка, вам нужно добавить заглавную или строчную букву F в конце десятичного значения, например, вы должны ввести "13.63 F’ вместо просто "13.63". Однако если вы написали float myFloat = 13.63, это вызовет ошибку, указывающую на то, что компилятор нашел double, когда требуется float. Вместо этого вам придется ввести "float myFloat = 13.63 F.".

Диапазоны:



Еще одна вещь, которую я хотел бы подчеркнуть, - это разница между знаковыми и беззнаковыми типами данных. Подпись означает, что если бы вы напечатали значение типа данных, то могли бы увидеть отрицательный знак. Например, байт имеет диапазон от -128 до 127. Вы можете задаться вопросом, почему диапазон заканчивается на 127 вместо 128. Это происходит потому, что Java использует это пространство для хранения положительного или отрицательного знака числа.

Примером типа данных без знака является символ char. Символ хранит символы, однако вы можете привести символ к числовому типу, как показано в коде ниже. В данном случае это всегда положительное число - диапазон char от 0 до 65535.

char myChar = ‘s’;
System.out.println("char default value as int" + (int) myChar);

116

Типы обертки

Еще одним нюансом примитивных типов является то, что они существуют параллельно как объекты, известные как “типы-оболочки”.

Byte b = Byte.valueOf(myByte);

В примере кода выше мы имеем переменную b, инициализированную с помощью метода valueOf(). Метод valueOf() - это статический метод, который преобразует примитивный тип данных byte в объект Byte. При использовании valueOf () возвращается кэшированный байтовый объект, который сэкономит нам немного памяти. Чтобы создать новый объект, вы бы сказали: "новый байт(myByte)", но обычно это не должно быть необходимо.

Одна из причин полезности объектов-оболочек заключается в том, что их можно использовать в коллекциях. Коллекции - это структура, похожая на массивы, но они гораздо более гибкие. Коллекции очень полезны, потому что вы можете бросать предметы и вынимать их по своему желанию. Однако вы не можете добавить примитивные типы в коллекцию. Чтобы обойти это, у нас есть числовые объекты, которые “обернуты” вокруг примитивных значений.

Все обертки чисел расширяют абстрактный тип Number. Делая это, они все реализуют числовые функции и могут быть обработаны. Это позволяет преобразовать их обратно в примитивные типы.

Автоупаковка и автораспаковка

В Java 5 они также ввели метод автоматического преобразования из примитивного типа в соответствующий ему объект-оболочку, называемый “авто-бокс”, и преобразование из объектов-оболочек в примитивные типы, называемое “авто-распаковка”. Он активно используется разработчиками, однако я рекомендую вам избегать его использования, потому что это может привести к неприятным ошибкам NullPointerException или проблемам с производительностью.

Все примитивные значения не могут быть null, поэтому их использование никогда не вызовет исключение NullPointerException. Однако, если вы не инициализируете объект, значение будет равно null, а затем при вызове, скажем, b.byteValue(), это вызовет исключение NullPointerException. На самом деле вы не увидите его при написании кода, потому что компилятор автоматически преобразует объект-оболочку в примитивный тип данных, но вы увидите его при запуске кода. Вместо этого, вы должны использовать статический метод valueOf() метод, чтобы преобразовать ваши примитивные значения, их типы обертки.

Основание 2, основание 8 и основание 16

Java позволяет нам не только сохранять числа, используя базу 10, но также базу 2, базу 8 и базу 16. Это может быть полезно, если, например, у вас есть шестнадцатеричное значение в документации и вы хотите иметь то же самое значение в своем коде. Независимо от того, какую систему счисления вы используете, она не имеет ничего общего с тем, как хранятся значения. Компьютер всегда будет хранить их в вашей памяти в виде нулей и единиц, независимо от формата. Более того, они по умолчанию будут распечатаны в базе 10 точно так же, как и обычные числа. Если вы хотите отобразить свое значение в двоичном формате, вам нужны специальные параметры форматирования, которые я объясню в отдельной статье.

База 2 была введена в Java 7. До этого вы могли хранить только в базе 10, базе 8 и базе 16. В приведенном ниже коде вы можете увидеть некоторые значения в различных базах данных. Как я применяю в приведенном ниже примере, вы можете использовать подчеркивания, чтобы сделать числа более читабельными. Вы можете добавлять их практически в любом месте и в любом количестве. Единственное место, где вы не можете добавить подчеркивание, - это начало или конец числа.

@Test
public void shouldDemonstrateBases(){
    int binary = 0B10;
    int baseEight = 017;
    int hex = 0xA;
    System.out.println(binary);
    System.out.println(baseEight);
    System.out.println(hex);
}

Выход:

2
15
10

Как показано выше, вы инициализируете переменные значениями из альтернативных систем счисления, которые необходимо указать в своем коде. Для двоичных чисел вы должны начинать свои числа с ‘0B’ или ‘0b’. Для базы 8 значение начинается с " 0’. Для базы 16 шестнадцатеричный код начинается с "0x", а числа 10-15 представлены " ABCDEF’ или ‘abcdef’ соответственно.