Классы-обертки в Java

🔥 🚀 Важно для всех, кто работает с Java! 🔥
На JavaRocks ты найдешь уникальные туториалы, практические задачи и редкие книги, которых не найти в свободном доступе. Присоединяйся к нашему Telegram-каналу JavaRocks — стань частью профессионального сообщества! 

Привет! Вы, скорее всего, уже хорошо знакомы с примитивными типами данных в Java и имеете опыт работы с ними.

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

Изучая Java, мы часто слышали мантру «все в Java – это объект».

Однако примитивные типы данных прямо противоречат этому утверждению, поскольку они не являются объектами. Это может поставить под сомнение принцип «все есть объект». Но на самом деле это не так. В Java для каждого примитивного типа существует соответствующий класс-обертка.

Что такое класс-обертка?

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

Имена классов-оберток очень схожи (или полностью совпадают) с именами соответствующих примитивных типов данных. Поэтому их легко запомнить.

Объекты-обертки создаются так же, как и любые другие объекты:

public static void main(String[] args) {

   Integer i = new Integer(682);

   Double d = new Double(2.33);

   Boolean b = new Boolean(false);
}

Классы-обертки позволяют преодолеть ограничения примитивных типов данных.

Одним из наиболее очевидных недостатков примитивов является то, что они не имеют методов.

Например, они не имеют метода toString(), поэтому вы не можете, например, преобразовать int в String.

Однако класс-обертка Integer предоставляет такую возможность, упрощая эту задачу.

public static void main(String[] args) {

   Integer i = new Integer(432);

   String s = i.toString();
}

Преобразование в обратном направлении может быть сложнее.

Предположим, у нас есть строка String, которая содержит числовое значение.

Независимо от этого, у примитивного типа int нет собственного способа извлечь числовое значение из строки String и преобразовать его в число.

Но мы можем выполнить это преобразование с помощью классов-оберток.

public static void main(String[] args) {

   String s = "1166628";

   Integer i = Integer.parseInt(s);

   System.out.println(i);
}

Вывод:

1166628

Мы успешно извлекли числовое значение из строки String и присвоили его ссылочной переменной типа Integer, назвав её i.

Кстати, о ссылках.

Вы уже знаете, что аргументы в методах передаются разными способами: примитивные типы данных передаются по значению, а объекты – по ссылке.

Можно применить эти знания при создании собственных методов. Например, если ваш метод использует дробные числа, но вам требуется передавать их по ссылке, вы можете использовать ссылочные типы Double или Float вместо примитивных double или float.

Помимо методов классов-оберток, их статические поля также могут быть очень удобными.

Например, представьте, что у вас есть следующая задача: вывести максимально возможное значение int, а затем минимально возможное значение.

Эта задача может показаться довольно простой, но без использования дополнительных ресурсов, таких как Google, вы вряд ли сможете ее решить.

Однако классы-обертки позволяют легко справляться с подобными «обыденными» задачами:

public class Main {
   public static void main(String[] args) {

       System.out.println(Integer.MAX_VALUE);
       System.out.println(Integer.MIN_VALUE);
   }
}

Эти поля позволяют не отвлекаться от выполнения более серьезных задач.

Не говоря уже о том, что ввод 2147483647 (что является значением MAX_VALUE) — немалый подвиг!

Кроме того, как мы отмечали в предыдущем уроке, объекты-обертки являются неизменяемыми.

public static void main(String[] args) {

   Integer a = new Integer(0);
   Integer b = new Integer(0);

   b = a;
   a = 1;
   System.out.println(b);
}

Вывод:

0

Состояние объекта, на который первоначально указывала переменная a, не изменилось (потому что в этом случае значение переменной b также изменилось бы).

Аналогично тому, как это происходит со строками, вместо изменения состояния объекта-обертки в памяти создается совершенно новый объект. Но почему же создатели Java решили оставить в языке примитивные типы данных?

Если все в Java должно быть объектом, а у нас есть классы-обертки, которые могут выражать все, что выражают примитивные типы, то возникает вопрос: почему бы не оставить в языке только обертки и не убрать примитивные типы?

Ответ прост: производительность.

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

Иногда все, что вам нужно, – это число 33, или 2,62, или true/false. В ситуациях, когда преимущества объектов не имеют значения и не требуются для работы программы, примитивные типы гораздо лучше справляются с задачей.

Перевод статьи «Wrapper Classes in Java».