Конструирование объектов в Java

Как создаются объекты в Java - тема не лишенная некоторых нюансов. Проблема в том, что детальное рассмотрение данного процесса во многих учебниках опущено. Однако, зачастую неправильное или неполное понимание алгоритма создания объекта может привести к ошибкам в программе, в том числе и уровня компиляции.

Рассмотрим процесс конструирования объекта в Java по шагам, двигаясь от простого к сложному - от создания одного класса до создания иерархии:

1 Создание одиночного объекта

     1.1 Конструктор по умолчанию
     1.2 Константы
     1.3 Инициализированные поля
     1.4 Исключения в конструкторах
     1.5 Блок статической инициализации

2 Отцы и дети

3 Общий алгоритм создания объекта

1 Создание одиночного объекта

Прежде всего отметим, что любой класс в Java имеет предка - класс Object. Но класс Оbject довольно известен, его поля и методы описаны и знакомы. Поэтому абстрагируемся от класса Object и рассмотрим создание объекта класса, не имеющего предка.

1.1 Конструктор по умолчанию

Любой класс в Java имеет конструктор. Если программист явно не создаст классу конструктор, то конструктор будет создан на этапе компиляции. Такой конструктор называется конструктором по умолчанию и имеет следующую сигнатуру:

1. public Parent()


2. {


3.     ...


4. }

Что находится внутри данного конструктора рассмотрим чуть позже.

Если же программист создал для класса хоть один конструктор (не важно с параметрами или без) - конструктор по умолчанию не создается!

Следующий код вызовет ошибку времени компиляции:

1. public class Parent


2. {


3.     public Parent(int i)


4.     {


5.         System.out.println("Parent::Parent(int i)");


6.     }


7. }


8.  


9. public class Demo


10. {


11.     public static void main(String[] args)


12.     {


13.         Parent p = new Parent();


14.     }


15. }


16.  

Дело в том, что теперь конструктор Parent() не определен. Особенно важен данный факт при наследовании.

1.2 Константы

Константа - публичное поле класса с модификатором final. Т.е. неизменяемое. Константы бывают уровня класса (static) и уровня объекта. 

Константы уровня класса определяются следующим образом:

1. public class  Parent


2. {  


3.     public static final int MAX = 300;


4.         ...


5. }

Особенность их в том, что нигде в байт-коде класса им не присваивается значение! Константа описывается лишь в секции Fields и имеет один атрибут - ConstantValue (значение). Дело в том, что компилятор заменяет везде в коде такую константу на соответствующее ей значение. Осуществляется этакий препроцессинг. Поэтому, кстати, при изменении значения константы будут перекомпилированы все использующие ее классы.

Константы уровня объекта определяются следующим образом:

1. public class  Parent


2. {


3.    public final int MAX = 400;


4.    ...


5. }

Если посмотреть скомпилированный байт-код (например, с помощью jclasslib bytecode viewer), то увидим следующее (метод init - конструктор)

1. 0 aload_0


2. 1 invokespecial #14


3. 4 aload_0


4. 5 sipush 400


5. ...

Т.е. значение константе уровня объекта (без модификатора static) присваивается в начале конструктора класса. Это единственное место, где изменяется
значение переменной с модификатором final. Так же важно знать, что значение задается в каждом конструкторе, в том числе и в конструкторе по-умолчанию.

1.3 Инициализированные поля

На самом деле инициализированные поля, т.е. поля, объявляемые как:

1. public class Parent


2. {  


3.    int i = 200;


4.    ...


5. }

мало чем отличаются от констант уровня объекта. Инициализация таких полей осуществляется так же в конструкторах класса:

1. 0 aload_0


2. 1 invokespecial #10


3. 4 aload_0


4. 5 sipush 200


5. 8 putfield #12

Таким образом можно понять общий алгоритм создания экземпляра класса. Но из каждого правила существуют исключения.

1.4 Исключения в конструкторах

Программисты на С++ не любят выбрасывать исключения в конструкторе класса. Оно и понятно, когда выбрасывается исключение в конструкторе, создание объекта останавливается. Соответственно, освободить уже выделенную под данный объект память будет невозможно. Посмотрим к чему приводит выбрасывание исключений в конструкторе с точки зрения Java.

Первое и самое существенное отличие - в Java есть такая классная штука, как сборка мусора. Здесь не место спорам на тему нужна ли она вообще, что лучше сборка мусора или ручное управление памятью и т.д. Сборка мусора в Java есть - это аксиома. Соответственно распределенная на момент выбрасывания исключения память будет освобождена. Хотя, если очень извратиться, то получить утечку памяти, используя исключения, можно.
 
Если в конструкторе объекта будет брошено исключение - создан он не будет. Например, следующий код при выполнении выведет null:

1. public class  Parent


2. {  


3.     int i = 200;


4.  


5.     public Parent()


6.     {


7.         i = 0;    


8.         System.out.println("Parent i/0 = " + i/0);


9.         System.out.println("Parent::Parent()");      


10.         i = 200;


11.     }


12.  


13.     public Parent(int i)


14.     {    


15.         System.out.println("Parent::Parent(int i)");


16.     }


17.  


18.     public int getI()


19.     {


20.         return i;


21.     }


22. }


23.  


24. public class Main


25. {


26.     public static void main(String[] args)


27.     {


28.         Parent p = null;


29.         try


30.         {


31.             p = new Parent();


32.         }


33.         catch (Exception ex)


34.         {


35.             System.out.println("OOPS Exception");


36.             ex.printStackTrace();


37.         }


38.  


39.         System.out.println(p);


40.     }


41. }

Дело в том, что в конструкторе класса Parent присутствует деление на ноль. Соответственно, будет брошено исключение, которое будет обработано в классе Main, но объект класса Parent создан не будет. Данную ситуацию обязательно необходимо обработать, иначе можно получить много "приятных" сюрпризов. Самым безобидным из них будет NPE.

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

1.5 Блок статической инициализации.

Блок статической инициализации вызывается в программе один раз - при загрузке класса, т.е. до вызова конструктора класса либо до обращения к статической переменной класса. Между обращениями к различным статическим переменным блок статической инициализации вызываться не будет. Под обращением к статической переменной (имеется ввиду именно переменная, т.е. без модификатора final) имеется ввиду как ее чтение, так и запись.

Блок статической инициализации присутствует в программе не всегда, даже если в классе объявлена статическая переменная. Например, в данном классе нет блока статической инициализации:

1. public  class Parent


2. {  


3.     public static int MAX;      


4.  


5.     public final int i = 200;  


6.  


7.     public Parent()


8.     {


9.         System.out.println("Parent::Parent()");


10.     }


11.  


12.     public Parent(int i)


13.     {    


14.         System.out.println("Parent::Parent(int i)");


15.     }


16.  


17.     public int getI()


18.     {


19.         return i;


20.     }


21. }

Но если написать так:

1. public  static int MAX = 100;

то блок статической инициализации будет создан. Собственно, именно в нем и происходит присваивание значения статической переменной MAX.

И конечно никто не мешает определить данный блок явно:

1. public class Parent


2. {  


3.     public static int MAX;  


4.  


5.     static


6.     {


7.         MAX = 200;


8.         System.out.println("Parent::MAX = " + MAX);


9.     }


10.     ...


11. }

С созданием одиночного объекта завершили, теперь перейдем к построению иерархии.

2 Отцы и дети

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

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

Причем, если не указано явно - вызывается конструктор без параметров (созданный явно или по-умолчанию). Но данный конструктор может отсутствовать. Например, такой код вызовет ошибку времени компиляции:

1. public class Parent


2. {  


3.     public Parent(int i)


4.     {    


5.         System.out.println("Parent::Parent(int i)");


6.     }  


7. }


8.  


9. public class Child extends Parent


10. {


11.     int i = 100;  


12.  


13.     public Child()


14.     {


15.  


16.     }


17.  


18.     public int getI()


19.     {


20.         return i;


21.     }


22. }

Дело в том, что при создании класса Child должен быть вызван конструктор без параметров класса Parent, которого нет.

Исправить такие ошибки можно, вызывая конструктор базового класса явно, через ключевое слово super:

1. public  class Child extends Parent


2. {


3.     int i = 100;


4.  


5.     public Child()


6.     {


7.         super(10);


8.     }


9.  


10.     public int getI()


11.     {


12.         return i;


13.     }


14. }

Теперь будет вызываться конструктор с параметром, который мы и определили.

Больше про наследование применительно к построению объектов сказать нечего. Пора подводить итоги.

3 Общий алгоритм создания объекта

Итак, подводя итоги, составим общий алгоритм создания объекта: 

1. Вызывается блок статической инициализации базового класса (если он есть)

2. Вызывается блок статической инициализации создаваемого класса (если он есть)

3. Вызывается конструктор класса

3.1. Вызывается конструктор базового класса

3.2. Происходит инициализация переменных в порядке их определения.

3.3. Вызывается остальной код конструктора.

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

Понравилось сообщение - подпишись на блог через RSS