Блоки статической и объектной инициализации
Когда вы создаете объект, вам часто приходится устанавливать значение одного или нескольких переменных. В большинстве случаев это делает конструктор. Другие инструменты, которые могут устанавливать значение переменных — это блоки инициализации. Здесь мы рассмотрим блоки статической и объектной инициализации. Вы можете использовать эти блоки вместо или в дополнение к конструкторам. Вы также увидите, как эти блоки инициализации используются безымянными классами.
Давайте начнем со следующего примера. Программа SmallSquares (маленькие квадраты) возвращает квадрат маленького целого числа. SmallSquares имеет 2 статические переменные и единственную открытую статическую функцию getSquare().
public class SmallSquares <
private static final int LIMIT = 10 ;
private static final int [] square = new int [ LIMIT ] ;
public SmallSquares () < // не пишите такой код
for ( int i = 0 ; i < LIMIT; i++ ) square [ i ] = i * i;
>
>
>
public static int getSquare ( int i ) // Нет обработки ошибки, предположим, 0 return square [ i ] ;
>
public static void main ( String [] args ) new SmallSquares () ;
System.out.println ( «3 squared is » +
getSquare ( 3 )) ;
>
>
Откомпилируйте и запустите SmallSquares, вы должны получить следующий результат:
3 squared is 9 ( 3 в квадрате будет 9 )
Как вы наверное догадались из комментария программы, это действительно плохой код. Мы игнорируем недостаток границ проверки аргумента getSquare(). Также игнорируем тот факт, что индексация в очереди чуть ли не дороже, чем простое возведение в квадрат числа. Отложим эти факты в сторону, сконцентрируемся на неэкономном создании объекта, называемом статическим методом.
А ещё лучше использовать статическую инициализацию. За словом статический (static) следует блок кода, окруженного фигурными скобками. Вы можете использовать статический блок для инициализации массива квадратов вот так:
static <
for ( int i = 0 ; i < LIMIT; i++ ) <
square [ i ] = i * i;
>
>
Поставьте этот блок в код программы SmallSquare после объявления квадрата. Из-за статичности блок запрашивается единожды, когда создается класс. Теперь вам не нужен конструктор, и вы можете вызывать статическую функцию getSquare() без предшествующего создания класса. Вот улучшенный код:
public class SmallSquares <
private static final int LIMIT = 10 ;
private static final int [] square = new int [ LIMIT ] ;
static for ( int i = 0 ; i < LIMIT; i++ ) square [ i ] = i * i;
>
>
public static int getSquare ( int i ) // Нет обработки ошибки, предположим,0 return square [ i ] ;
>
public static void main ( String [] args ) System.out.println ( «3 squared is » + getSquare ( 3 )) ;
>
>
Вы можете применять этот же метод к нестатическим кодам. Отметим, что данные инициализаторы вводились таким образом, что безымянным внутренним классам приписывалось определенное состояние. В следующем примере вы увидите, как использовать данные инициализаторы в контексте стандартных классов инициализации. Этот метод наиболее подходящий для безымянные классов.
Код в программе, ConstructorExample (пример конструктора), снова инициализирует массив целых чисел. Существует 2 версии конструктора. Первая — конструктор без аргумента, который по умолчанию определяет значение «Безымянный» («Anonymous»). Во второй версии есть один аргумент: значение имя пользователя (userName). Конструкторы объединены, так как квадрат должен инициализироваться в каждом случае.
public class ConstructorExample <
private final String userName;
private final static int [] square = new int [ 10 ] ;
public ConstructorExample () < // так не следует писать
this ( «Anonymous» ) ;
>
public ConstructorExample ( String userName ) this .userName = userName;
for ( int i = 0 ; i < 10 ; i++ ) square [ i ] = i * i;
>
>
public void printSquare ( int i ) // no error handling — assume 0 System.out.println ( «Hello » + userName ) ;
System.out.println ( i + » squared is » + square [ i ]) ;
>
public static void main ( String [] args ) new ConstructorExample () .printSquare ( 3 ) ;
new ConstructorExample ( «Ed» ) .printSquare ( 5 ) ;
>
>
Откомпилируйте и запустите ConstructorExample. Вы должны получить следующий результат:
Hello Anonymous ( привет Безымянный )
3 squared is 9 ( 3 в квадрате будет 9 )
Hello Ed ( Привет Эд )
5 squared is 25 ( 5 в квадрате будет 25 )
Пример конструктора можно привести в порядок, переместив поле инициализатора для имени пользователя (userName) и введя следующий блок инициализатора:
<
for ( int i = 0 ; i < 10 ; i++ ) <
square [ i ] = i * i;
>
>
Данный блок инициализаторов выглядит как блок статического инициализатора без статического ключевого слова. Он запускается перед тем, как вызвать конструктор. Это значит, что вначале квадрат инициализируется не правильно в зависимости от того, вызывает ли пользователь конструктор без аргумента или использует сигнатуру, требующую строку (String). Отметить, что если у вас есть другой конструктор, который устанавливает размер массива, вы не сможете применять этот метод. Потому что данный инициализатор будет вызван, чтобы инициализировать квадрат, перед тем, как будет прочитан размер массива.
Вы можете разделить конструкторы в примере (ConstructorExample), передвинув следующие строки от конструктора без аргумента:
В следующей программе появляется пустой конструктор, ConstructorExample2 (пример конструктора 2), чтобы продемонстрировать введение данного блока инициализации.
public class ConstructorExample2 <
private final String userName;
private static final int [] square = new int [ 10 ] ;
for ( int i = 0 ; i < 10 ; i++ ) square [ i ] = i * i;
>
>
public ConstructorExample2 () userName = «Anonymous» ;
>
public ConstructorExample2 ( String userName ) this .userName = userName;
>
public void printSquare ( int i ) // Нет обработки ошибки, предположим,0 System.out.println ( «Hello » + userName ) ;
System.out.println ( i + » squared is » + square [ i ]) ;
>
public static void main ( String [] args ) new ConstructorExample2 () .printSquare ( 3 ) ;
new ConstructorExample2 ( «Ed» ) .printSquare ( 5 ) ;
>
>
Безымянный внутренний класс — это более естественная установка для данного инициализатора. Эти классы не могут иметь конструкторов, потому что у них нет имени. Однако, вам наверное придется инициализировать состояния в этих классах. Следующая программа, AnonymousExample(Безымянный пример), создает внутренний класс, называемый AnonymousSquare (безымянный квадрат). Внутренний класс использует данный блок инициализатора, чтобы инициализировать целочисленный массив квадратов из предыдущего примера. Переменные userName и i также объявлены, но их значения не установлены. Функция print() выводит сообщение, использующее все 3 переменные.
В примере AnonymousExample используется функция createAnonSquare(). Эта функция создает безымянный внутренний класс, который распространяется на AnonymousSquare (безымянный квадрат). Этот пример не более чем инициализация переменных userName и Ed.
new AnonymousSquare () <
<
userName = «Ed» ;
i = 3 ;
>
> ;
Безымянный класс наследует квадрат и функцию print(). Это значит, что вы можете создавать AnonymousSquare (Безымянный квадрат) и вызывать print(). Вы должны получить «Hi Ed, 3 squared is 9.» (Привет Эд, 3 в квадрате будет 9).
static class AnonymousSquare
private static final int [] square = new int [ 10 ] ;
for ( int i = 0 ; i < 10 ; i++ )
square [ i ] = i * i;
>
String userName;
int i;
void print () System.out.println ( «Hi » + userName + «, » + i
+ » squared is » + square [ i ] + ‘.’
) ;
>
>
static AnonymousSquare createAnonSquare () return new AnonymousSquare () userName = «Ed» ;
i = 3 ;
>
> ;
>
public static void main ( String [] args ) createAnonSquare () .print () ;
>
>
Однажды, попробовав работать с блоками инициализации, вы возможно найдёте для них много приложений. Данные инициализаторы лучше всего подходят к безымянным внутренним классам и не часто используются в обычных Java-классах. Вы убедитесь, что статические инициализаторы очень удобные.
A может Вас также заинтересует что-нибудь из этого:
- Разное → Теория и практика Java: Динамическая компиляция и измерение производительности
- Java Standard Edition → Блокировки
- Java Standard Edition → Производительность операций ввода/вывода в Java
- Java сниппеты → Методы для работы с переменным количеством аргументов
- Разное → C# глазами Java программиста
- Java сниппеты → Использование readResolve
Малоизвестные особенности Java
Готовясь к собеседованию, я решил освежить память да и вообще поискать каверзные и малоизвестные нюансы языка Java. Выборку пяти наиболее интересных на мой взгляд моментов я вам и предлагаю.
1. Нестатические блоки инициализации.
Всем, я думаю, известно, что в Java существуют статические блоки инициализации (class initializers), код которых выполняется при первой загрузке класса.
class Foo < static Listabc; static < abc = new LinkedList(); for (char c = 'A'; c > >Но существуют также и нестатические блоки инициализации (instance initializers). Они позволяют проводить инициализацию объектов вне зависимости от того, какой конструктор был вызван или, например, вести журналирование:
class Bar < < System.out.println("Bar: новый экземпляр"); >>Такой метод инициализации весьма полезен для анонимных внутренних классов, которые конструкторов иметь не могут. Кроме того, вопреки ограничению синтаксиса Java, используя их, мы можем элегантно инициализировать коллекцию:
Map map = new HashMap() >;Очень даже мощное средство, не находите?
JFrame frame = new JFrame() >); add(new JButton("Торт!") >); >>); >>); >>;Остальные четыре пункта под катом.
2. Вложенные в интерфейсы классы.
Вложенный (nested) в интерфейс класс является открытым (public) и статическим (static) даже без явного указания этих модификаторов. Помещая класс внутрь интерфейса, мы показываем, что он является неотъемлемой частью API этого интерфейса и более нигде не используется.
interface Colorable < public Color getColor(); public static class Color < private int red, green, blue; Color(int red, int green, int blue) < this.red = red; this.green = green; this.blue = blue; >int getRed() < return red; >int getGreen() < return green; >int getBlue() < return blue; >> > class Triangle implements Colorable < private Color color; // . @Override public Color getColor() < return color; >>Поскольку такой класс является статическим, мы можем создать его экземпляр, не ссылаясь на объект объемлющего класса, а лишь указывая тип внешнего интерфейса или реализующего его класса.
Colorable.Color color = new Colorable.Color(0, 0, 0); color = new Triangle.Color(255, 255, 255);Самым, наверное, известным примером этой идиомы является класс Map.Entry, содержащий пары ключ-значение ассоциативного словаря.
3. Коварианты возвращаемых типов.
Начиная с Java SE 5 типы возвращаемых результатов из методов ковариантны (covariant). Это означает, что мы можем в перекрытом методе (overriden) в качестве типа результата использовать подтип результата перекрываемого метода.
class Covariance implements Cloneable < @Override public Covariance clone() < Object cloned = null; try < cloned = super.clone(); >catch (CloneNotSupportedException exc) < // В данном примере недостижимо. >return (Covariance)cloned; > >Метод Object.clone() имеет такую сигнатуру:
protected Object clone()
Заметьте, возвращаемый тип изменён с Object на Covariance. Теперь, к примеру, нет нужды приводить результат работы метода clone() к действительному типу объекта, как это требовалось в ранних версиях JDK. Вместо этого кода:
Covariance foo = new Covariance(); Covariance bar = (Covariance)foo.clone();Мы можем смело писать код следующий:
Covariance foo = new Covariance(); Covariance bar = foo.clone();4. Выход из любого блока операторов.
Хотя goto и является зарезервированным ключевым словом Java, использовать его в своих программах нельзя. Пока? На смену ему пришли операторы break и continue, позволяющие прерывать и продолжать (соответственно) не только текущий цикл, но также и любой обрамляющий цикл, обозначенный меткой:
String a = "quadratic", b = "complexity"; boolean hasSame = false; outer: for (int i = 0; i < a.length(); ++i) < for (int j = 0; j < b.length(); ++j) < if (a.charAt(i) == b.charAt(j)) < hasSame = true; break outer; >> > System.out.println(hasSame);Но многие даже не догадываются, что в Java мы всё же можем при помощи оператора break не только прервать цикл, но и покинуть совершенно любой блок операторов. Чем не оператор goto, правда, односторонний? Как говорится, вперёд и ни шагу назад.
long factorial(int n) < long result = 1; scope: < if (n == 0) < break scope; >result = n * factorial(n - 1); > return result; >Практическая ценность от таких прыжков весьма сомнительна и нарушает принципы структурного программирования, но знать о такой возможности, я думаю, стоит.
5. Модификация данных из внутренних классов.
Хотя в Java и предусмотрено ключевое слово final, однако на деле отсутствует возможность задать неизменяемость самого объекта, а не указывающей на него ссылки (не относится к примитивам). Ну, в принципе, можно спроектировать неизменяемый (immutable) класс, предоставив только геттеры и чистые функции, но нельзя, к примеру, создать неизменяемый массив. Это, как мне кажется, существенное упущение в дизайне языка. Тут бы пригодилось зарезервированное, но запрещённое ключевое слово const. Ждём в следующих версиях?
final int[] array = ; new Object() < void twice() < for (int i = 0; i < array.length; ++i) < array[i] *= 2; >> >.twice();Таким образом, мы можем модиицировать хотя и финализированные, но фактически изменямые данные, будь то массивы либо другие неперсистентные объекты даже из контекста внутренних (inner) классов. Со строками и оболочками примитивных типов, к сожалению, такой фокус не пройдёт. Пусть вас ключевое слово final не вводит в заблуждение.
Если вам статья понравилась — продолжение следует.
Что такое статический блок и статическая инициализация в Java?
Статические блоки и статическая инициализация используются для инициализации статических полей в Java. Мы объявляем статический блок в тот момент, когда хотим проинициализировать статические поля в классе.
Статический блок выполняется только один раз, при загрузке класса загрузчиком.
Статический блок выполняется до вызова конструктора.
Также можно сказать что статические поля и методы принадлежат классу, нестатические — объекту.
Пример синтаксиса ниже:
public class StaticTest < public static class StatClass < static int i = 5; >public static class StaticBlockClass < static < int a = 3; int b = 10; if (b < a) System.out.println(a); else System.out.println(b); >> public static void main(String[] args) throws ClassNotFoundException < // Не создавая экземпляр класса мы можем обратиться к статическим полям благодаря статической инициализации System.out.println(StatClass.i); // При загрузке класса выполняется статический блок, в котором можно выполнять проверки и т.д. System.out.println(Class.forName(StaticBlockClass.class.getName())); >> Вывод: 5 10 class StaticTest$StaticBlockClass
Блоки инициализации в Java — Часть 1
Привет! В данной статье мы расскажем самое-самое основное про блоки инициализации в Java. Но у этой статьи будет продолжение — часть 2, в которой будут описаны более сложные аспекты. Приятного прочтения!
Что такое инициализация
Для того, чтобы понять, что такое блоки инициализации, давайте сначала разберемся что такое инициализация. Кстати, этот вопрос Вам могут задать на собеседовании! Так что, даже если Вы уже знаете, что это — давайте повторим.
Инициализация (от англ. initialize, от initial — «начальный, первоначальный») — это когда мы впервые задаем переменной какое-либо значение.
Например, у нас есть переменная: