Как вам известно, в языке Java используются базовые типы (также называемые простыми), такие как int или double, для хранения элементарных типов данных, поддерживаемых языком. Для хранения таких данных из-за более высокой производительности применяются базовые типы, а не объекты. В этом случае использование объектов добавляет неприемлемые издержки даже к простейшей вычислительной операции.

Несмотря на выигрыш в производительности, предлагаемый базовыми типами, возникают ситуации, требующие обязательного объектного представления. Например, много стандартных cтруктур данных, реализованных в языке Java, которые оперируют объектами, и, следовательно, вы не можете использовать эти структуры для хранения данных базовых типов. Для подобных случаев Java предоставляет оболочки типов, представляющие собой классы, которые инкапсулируют данные простого типа в объект (Float, Long, Integer, Short). Значение базового типа инкапсулируется в оболочку в момент конструирования объекта. Упакованное таким образом значение можно получить обратно с помощью вызова одного из методов, определенных в оболочке (byte byteValue(), double doubleValue()).

Процесс инкапсуляции значения в объект называется упаковкой (boxing). До появления Java 2 версии 5.0 вся упаковка выполнялась программистом вручную, с помощью создания экземпляра оболочки с нужным значением. Процесс извлечения значения из оболочки типа называется распаковкой (unboxing). И снова, до появления Java 2 версии 5.0 вся распаковка выполнялась вручную с помощью вызова метода оболочки для получения значения из объекта. Хотя такой способ упаковки и распаковки работает, он утомителен и подвержен ошибкам, так как требует от программиста вручную создавать подходящий объект для упаковки значения и при необходимости его распаковки явно задавать переменную соответствующего базового типа. Java 2, v5.0 коренным образом модернизирует эти важнейшие процедуры, вводя средства автоупаковки/распаковки.

Имеется:

List list = new LinkedList();

list.add(new Integer(1));

list.add(new Integer(10));

Хотелось бы:

List list = new LinkedList();

list.add(1);

list.add(10);

• Автоупаковка – процесс автоматической инкапсуляции данных простого типа в экземпляр соответствующего ему класса-обертки в случаях, когда требуется значение ссылочного типа

• Автораспаковка – процесс автоматического извлечения примитивного значения из объекта-упаковки в случаях, когда требуется значение примитивного типа

List list = new LinkedList();

list.add(1);

int b = (Integer)list.get(0) + 10;

С появлением Java 2 v5.0 стало возможным использование объекта типа Boolean для управления оператором if и любыми операторами цикла языка Java. Когда объект типа Boolean используется как условное выражение в циклах while, for, do/while, он автоматически распаковывается в эквивалент простого типа boolean.

Boolean b;

//

while (b) { //

Кроме удобства, которое предоставляет механизм автоупаковки/распаковки, он может помочь в предупреждении ошибок. Так как автоупаковка всегда создает правильный объект, а автораспаковка всегда извлекает надлежащее значение, не возникает ситуаций для формирования неверного типа объекта или значения. В тех случаях, когда вам нужен тип, отличающийся от созданного автоматическим процессом, вы и сейчас можете упаковывать и распаковывать значения вручную так, как делали это раньше.

Особенности автоупаковки

• Происходит при присваивании, вычислении выражений и при передаче параметров.

• Объекты создаются без использования ключевого слова new
Integer i = 15;

• Объекты создаются!

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

• Автоупаковка требует существенных ресурсов.

• Злоупотреблять автоупаковкой не стоит!

Аргументы переменной длины

Версия Java 2 5.0 содержит новое средство, упрощающее создание методов, которым приходится принимать разное количество аргументов. Ситуации, требующие передачи методу переменного числа аргументов, не так уж редки. Например, метод, открывающий интернет-соединение, может принимать имя пользователя, пароль, имя файла, протокол и так далее, но при отсутствии некоторых из этих аргументов способен заменить их значениями по умолчанию. В этом случае было бы удобно передавать только те аргументы, значения которых отличаются от значений по умолчанию. До выхода версии Java 2 5.0 переменное количество аргументов обрабатывалось несколькими способами, ни один из которых нельзя назвать удобным. Во-первых, если максимальное число аргументов не велико и известно, можно было создать перегружаемые версии метода, по одной на каждый вариант списка передаваемых в метод аргументов. Если максимальное количество аргументов было велико или неизвестно, применялся второй способ: аргументы помещались в массив, и этот массив передавался методу.

Имеется:

int s1 = sum(new int[] {1, 2});

int s2 = sum(new int[] {1, 2, 3});

Хотелось бы:

int s1 = sum(1, 2);

int s2 = sum(1, 2, 3, 4);

Новое средство написания методов с произвольным количеством аргументов предлагает более простой и удобный способ. Аргумент переменной длины (содержащий переменное число аргументов) задается тремя точками (...). Далее приведен пример описания метода sum , использующего аргумент переменной длины. Эта синтаксическая запись сообщает компилятору, что sumt() может вызываться без параметров, с одним или несколькими параметрами. В результате переменная a, аргумент переменной длины, неявно объявляется массивом типа int[ ]. Таким образом, в теле метода sum() для доступа к a используется нормальный синтаксис работы с массивом.

int sum ( int ... a ) {

int s = 0;

for (int i = 0; i < a.length; i++)

s += a[i];

return s;

}

int s2 = sum(1, 2, 3);

int s1 = sum(new int[] {1, 2});