Предисловие
В Java объект должен быть правильно инициализирован, прежде чем его можно будет использовать, что предусмотрено спецификацией Java.
Автоматическая инициализация (по умолчанию)
Все основные данные класса будут инициализированы. Запустите следующий пример, чтобы просмотреть эти значения по умолчанию:
класс по умолчанию {boolean t; Чар C; байт B; короткие S; int i; Long L; float f; двойной D; public void show () {system.out.println ("значение базового типа инициализации/n" + "boolean <----->" + t + "/n" + "char <------>" + c + "/n" + "byte <------->" + b + "/n" + "Short <------>" + "/n" + " +" + "/n"/n "/n"/n "/n"/n "/n"/n "/n"/n "/n"/n "/n". l + "/n" + "float <------>" + f + "/n" + "double <----->" + d + "/n"); }} открытый класс initValue {public static void main (string [] args) {по умолчанию d = new Default (); d.show (); }}【Результаты работы】:
Значение инициализации базового типа
Boolean <-----> Неверно
char <----->
Byte <-----> 0
Короткий <-----> 0
int <-----> 0
long <-----> 0
float <-----> 0,0
Двойной <-----> 0,0
Где значение по умолчанию типа символа равна нулю.
Для непримизных типов данных ручка объекта также инициализируется:
Класс Человек {Private String name; // setter} класс по умолчанию {person p; public void show () {System.out.println ("Человек <---->" + p); }} открытый класс initValue {public static void main (string [] args) {по умолчанию d = new Default (); d.show (); }}【Результаты работы】:
Человек <-----> null
Видно, что значение инициализации ручки равна нулю. Это означает, что если метод, аналогичный p.setName вызывается без указания значения инициализации для P, произойдет исключение.
Правила инициализация
Если вам нужно присвоить первоначальное значение самостоятельно, вы можете присвоить значение при определении переменной.
класс по умолчанию {boolean t = true; char c = 'a'; байт B = 47; короткий s = 0xff; int i = 24; Long L = 999; float f = 1,2f; Double D = 1,732; public void show () {system.out.println ("boolean <----->" + t + "/n" + "char <------>" + c + "/n" + "byte <------>" + b + "/n" + "short <------>" + s + "/n" + "int <------>" + i + "/n"/n " +"/n "/n"/n "/n"/n "/n"/n "/n"/n "/n"/n "/n"/n "/n"/n "/n"/n "/n"/n "/n"/n "/n". "float <------>" + f + "/n" + "double <------>" + d + "/n"); }} открытый класс initValue {public static void main (string [] args) {по умолчанию d = new Default (); d.show (); }}Это может быть даже инициализировано одним способом;
класс Человек {int i = set (); // ...}Эти методы также могут использовать независимые переменные:
класс человек {int i; int j = set (i); // ...} Инициализация строителя
Преимущество инициализации строителя состоит в том, что значение инициализации может быть определена во время выполнения. Например:
классный человек {int возраст; Человек () {возраст = 89; }}Возраст сначала будет инициализирован до 0, а затем станет 89. Это верно для всех основных типов, а также для обработки объектов.
Порядок инициализации
В классе порядок инициализации определяется порядок, в котором переменные определяются в классе. Даже если определения переменной в значительной степени распространяются по середине определения метода, переменная все равно будет инициализирована перед вызовом любого метода (включая конструктор). Например:
класс pet {pet (int age) {system.out.println ("pet (" + age + ")"); }} класс Person {PET T1 = новый PET (1); Person () {System.out.println ("--- Person () ---"); T3 = новый питомец (33); } PET T2 = новый PET (2); void show () {system.out.println ("show ----- running"); } Pet t3 = new pet (3);} public class orderofinitialization {public static void main (string [] args) {person p = new Person (); p.show (); }}【Результаты работы】:
Домашнее животное (1)
Домашнее животное (2)
Домашнее животное (3)
--Человек()---
ПЭТ (33) <br/>
Показать ----- Бег
В приведенном выше примере, хотя определения T1, T2 и T3 находятся по всему классу, порядок инициализации определяется по порядку определения T1, T2 и T3 (изменение T1, T2 и T3 самим, чтобы увидеть результат), а инициализация имеет приоритет над выполнением строителя. Когда называется строитель человека, T3 повторно инициализируется.
Инициализация статических данных
Если данные статические, будет выполнен тот же процесс. Если он является примитивным типом и не инициализируется, он автоматически получит свое собственное стандартное начальное значение примитивного типа; Если это ручка для объекта, он получит нулевое значение, если объект не будет создан и не подключен к нему. Если инициализируется во время определения, принятый метод отличается от нестатического значения, поскольку статика имеет только одну область хранения. Например:
Class Bowl {bowl (int marker) {System.out.println ("Bowl (" + Marker + ")"); } void f (int marker) {System.out.println ("f (" + marker + ")"); }} таблица класса {статическая чаша B1 = новая чаша (1); Table () {System.out.println ("table ()"); b2.f (1); } void f2 (int marker) {System.out.println ("f2 (" + marker + ")"); } статическая чаша B2 = новая чаша (2);} Class Cupboard {Bowl B3 = New Bowl (3); статическая чаша B4 = новая чаша (4); Cupboard () {System.out.println ("cupboard ()"); b4.f (2); } void f3 (int marker) {System.out.println ("f3 (" + marker + ")"); } Статическая чаша B5 = Новая чаша (5);} открытый класс статициализация {public static void main (string [] args) {System.out.println («Создание нового шкафа () в main»); новый шкаф (); System.out.println («Создание нового шкафа () в основном»); новый шкаф (); t2.f2 (1); t3.f3 (1); } статическая таблица T2 = новая таблица (); Статический шкаф T3 = новый шкаф ();}【Результаты работы】:
Чаша (1)
Чаша (2)
Стол()
F (1)
Чаша (4)
Чаша (5)
Чаша (3)
Буфет()
F (2)
Создание нового шкафа () в главном
Чаша (3)
Буфет()
F (2)
Создание нового шкафа () в главном
Чаша (3)
Буфет()
F (2)
F2 (1)
F3 (1)
Статические кодовые блоки
Java позволяет разделить другую статическую инициализацию на специальный кодовый блок в классе. Этот кодовый блок находится в форме статического ключевого слова, за которым следует кузов метода, называемый статический кодовый блок. Статический кодовый блок выполняется только тогда, когда объект этого класса сгенерирован впервые или статический член, принадлежащий этому классу, доступ к ним впервые. Например:
класс человека {person (int age) {System.out.println ("Person (" + age + ")"); } void f (int age) {System.out.println ("f (" + age + ")"); }} класс лиц {статический человек P1; статический человек P2; static {p1 = новый человек (1); P2 = новый человек (2); } Persons () {System.out.println ("persons ()"); }} public class explicitStatic {public static void main (string [] args) {System.out.println ("inside main ()"); Persons.p1.f (18); // 1} статические лица x = new Persons (); // 2 Статические лица y = new Persons (); // 2}При доступе к статическому объекту P1 в строке, помеченной 1, или если строка 1 прокомментирована и строка 2 не прокомментирована, модуль статической инициализации для лиц будет работать. Если как 1, так и 2 прокомментированы, статический кодовый блок, используемый для лиц, не будет выполнен.
Порядок статических свойств и выполнения статического блока кода
класс человека {person (int age) {System.out.println ("Person ("+age+")"); }} класс лиц {статический человек p = новый человек (2); // 1 static {p = новый человек (3); } статический человек p = новый человек (2); // 2} открытый класс compstaticinit {public static void main (string [] args) {} статические лица x = new Persons ();}Согласно анализу результатов аннотации 1, удерживающего 2 и аннотации 2 удержания 1, можно видеть, что порядок выполнения статических свойств и статических блоков кода зависит от порядка кодирования. Тот, кто впереди, будет казнен в первую очередь.
Инициализация нестатических свойств
класс животное {животное (int age) {System.out.println ("Animal (" + age + ")"); } void f (int age) {System.out.println ("f (" + age + ")"); }} public Class notStaticInit {Animal A1; Животное A2; {a1 = новое животное (1); A2 = новое животное (2); System.out.println ("A1 & A2 инициализировано"); } NotstaticInit () {System.out.println ("notStaticInit"); } public static void main (string [] args) {System.out.println ("Inside main ()"); NotstaticInit x = new NotStaticInit (); }}Подобно статическим блокам кода, порядок инициализации анонимных кодовых блоков с нестатическими свойствами зависит от порядка кодирования .
Процесс инициализации унаследованного объекта
класс насекомые {int i = 1; int j; Insect () {prt ("i =" + i + ", j =" + j); J = 2; } static int x1 = prt ("Статическое насекомое.x1 инициализировано"); static int prt (string s) {System.out.println (s); возврат 3; }} открытый класс жутл расширяет насекомые {int k = prt ("beeklt.k инициализирован"); Beetle () {prt ("k =" + k); prt ("j =" + j); } static int x2 = prt ("static bootle.x2 инициализирован"); static int prt (string s) {System.out.println (s); возврат 4; } public static void main (string [] args) {prt ("Constructor Beetle"); Жук B = новый жук (); }}【Результаты работы】:
Статическое насекомое. X1 Инициализировано
Статический Bootle.x2 инициализирован
Жук конструктор
i = 1, j = 0
Beeklt.k инициализировался
k = 4
J = 2
Первое, что происходит при запуске Java на Beetle, - это загрузчик, чтобы найти этот класс снаружи. В процессе загрузки загрузчик обнаруживает базовый класс, поэтому он загружается соответственно. Этот процесс будет выполнен независимо от того, генерируется ли объект базового класса или нет. Если базовый класс содержит другой базовый класс, другой базовый класс будет загружен и т. Д. Затем выполните статическую инициализацию в базовом классе корневых, затем выполните в следующем производном классе и так далее. Это связано с тем, что инициализация производного класса может зависеть от инициализации базовых членов класса.
Когда все классы загружаются, объекты могут быть созданы. Во -первых, все основные типы данных в этом объекте устанавливаются на значения по умолчанию, а дескриптор объектов устанавливается на NULL. Затем выполните строитель базового класса. Эта ситуация выполняется автоматически ( super()， а строитель базового класса также может быть указан через Super). После того, как строитель базового класса будет завершен, переменные экземпляра полученного класса будут инициализированы в их первоначальном порядке, а оставшиеся части корпуса будут выполнены.
Суммируйте процесс создания объектов:
Статическое выполнение выполняется только тогда, когда класс загружен и только один раз;
Нестатическое выполняется только при создании, и выполняется каждый раз, когда создается объект;
Статическое выполнение выполняется перед нестатическим, а статический класс базового класса предшествует статическому выполнению по производным классам;
Свойства выполнения статических свойств и статических кодовых блоков зависят от их позиции в классе, и кто первым выполняет их;
Порядок выполнения нестатических свойств и блоков конструкторов зависит от их позиции в классе и который выполняет перед ними.
Суммировать
Благодаря вышеупомянутому введению у нас есть несколько способов инициализации объектов в Java и как выполнить код инициализации, а также представляет ситуации, которые мы можем использовать ненициализированные переменные. После получения подробного понимания этих проблем вы можете избежать некоторых рисков в кодировании, чтобы гарантировать, что объект полностью инициализирован, прежде чем он станет видимым.