Порядок инициализации статической переменной
1. Простые правила
Во -первых, давайте посмотрим на самый распространенный код Java:
открытый тест класса {public static test1 t = new Test1 (); общественный статический int a = 0; общественный статический int b; public static void main (String [] arg) {System.out.println (test.a); System.out.println (test.b); }} class test1 {public test1 () {test.a ++; Test.b ++; }}Вот предположение, что такое выходной результат консоли?
ОК, может быть, вы догадались приведенным ниже результатом, так что вы все еще знакомы с Java.
Скопируйте код следующим образом: 0 1
Если вы не понимаете, почему вышеупомянутый результат является выводом, то я скажу вам.
Инициализация статической переменной Java следует следующим правилам:
Прочитав это, вы поймете, что ценность теста. A изменилась три раза.
Установить 0, когда объявлен >> test1 :: test1 установлен в 1 >> test.a инициализируется до 0
2. Сложные правила
Если вы понимаете это, пожалуйста, посмотрите на код ниже.
открытый класс A {public static int b = ba; public static a plus = new a ("a"); Public Static Final int finalint = (int) (math.random ()*100); Public Static B P = новый B ("A"); Public Static Final String FinalStr = "FinalStr"; Public Static Final Integer FinalInteger = New Integer (10); общественный статический int a = 1; Public Static B C = NULL; public a (string from) {system.out.println ("----------- begin a :: a ----------------"); System.out.println ("a :: a, from ="+from); System.out.println ("a :: a, ab ="+ab); System.out.println ("a :: a, a.finalint ="+a.finalint); System.out.println ("a :: a, ba ="+ba); System.out.println ("a :: a, b.plus ="+b.plus); System.out.println ("----------- End A :: A ----------------"); } public static void main (string [] arg) {system.out.println ("main, ab ="+ab); System.out.println ("main, bt ="+bt); System.out.println ("main, ca ="+ca); }} класс B {public static int t = aa; public static a plus = new a ("b"); общественный статический int a = 1; public b (string from) {System.out.println ("----------- begin b :: b -----------------------"); System.out.println ("b :: b, from ="+from); System.out.println ("b :: b, ba ="+ba); System.out.println ("b :: b, aa ="+aa); System.out.println ("b :: b, ap ="+ap); System.out.println ("b :: b, a.plus ="+a.plus); System.out.println ("b :: b, a.finalint ="+a.finalint); System.out.println ("b :: b, a.finalint ="+a.finalint); System.out.println ("b :: b, a.finalint ="+a.finalint); System.out.println ("b :: b, a.finalint ="+a.finalint); System.out.println ("b :: b, a.finalinteger ="+a.finalinteger); System.out.println ("b :: b, a.finalstr ="+a.finalstr); System.out.println ("----------- Конец B :: B ----------------"); }} класс C {public static final a = new a ("c");}Можете ли вы догадаться результатом вывода? Я написал это во время тестирования, поэтому я не догадался. Хаха
Результат вывода консоли:
----------- begin a :: a ---------------- a :: a, from = ba :: a, ab = 0a :: a, a.finalint = 0a :: a, ba = 0a :: a, b.plus = null ----------- End a :: a ----------------------------- A.finalint = 0a :: a, ba = 1a :: a, b.plus=a@a90653---------- Эние A.finalint = 61b :: b, a.finalinteger = nullb :: b, a.finalstr = finalstr ----------- End b :: b ---------------- Main, ab = 1main, bt = 0 ----------- begin a :: a ---------------- A :: a, a: a ,: a, ab = 1a :: a, a. B.plus=a@a90653---------- End A :: A -------------------- Main, CA = A@61DE33
Вы не догадались об этом результате, ха -ха.
Требуется много времени, чтобы объяснить результаты выполнения программы один за другим. Здесь мы будем напрямую записать правила, за которыми следуют статическая инициализация переменной Java.
Правила в первом абзаце все еще действительны, но они не являются обоснованными.
Инициализация статических данных
Добавление статических квалифицированных полей является так называемым полем класса, что означает, что владелец этого поля не является объектом, а классом. Независимо от того, сколько объектов создано, есть только одна копия статических данных.
Статическое поле всегда инициализируется в классе, а затем инициализируется общее поле. Затем инициализируйте конструктор. Однако, если объект этого класса не создан, объект не будет инициализирован и будет выполнен только один раз.
Как и в следующем коде, в классе статитициализации статическая таблица таблицы = new Table (); Сначала, а затем объект таблицы не будет инициализирован, иначе он не будет инициализирован.
Class Bowl {bowl (int marker) {print ("bowl (" + marker + ")"); } void f1 (int marker) {print ("f1 (" + marker + ")"); }} таблица класса {статическая чаша чаша1 = новая чаша (1); Table () {print ("table ()"); Bowl2.f1 (1); } void f2 (int marker) {print ("f2 (" + marker + ")"); } статическая чаша Bowl2 = Новая чаша (2);} Класс Шкаф {Bowl Bowl3 = Новая чаша (3); статическая чаша чаша4 = новая чаша (4); Cackboard () {print ("cupboard ()"); Bowl4.f1 (2); } void f3 (int marker) {print ("f3 (" + marker + ")"); } static bowl Bowl5 = новая чаша (5);} открытый класс Статициализация {public static void main (string [] args) {print ("Создание нового шкафа () в Main"); новый шкаф (); print («Создание нового шкафа () в основном»); новый шкаф (); Table.f2 (1); шкаф.f3 (1); } статическая таблица = новая таблица (); Статический шкаф шкаф = новый шкаф ();}Выход:
Чаша (1) Чаша (2) Таблица () F1 (1) Чаша (4) Чаша (5) Чаша (3) Шкаф () F1 (2) Создание нового шкафа () в MainWork (3) Coupboard () F1 (2) Создание нового шкафа () в Mainbowl (3) Coupboard () F1 (2) F2 (1) F3 (1) (1).
Отображаемая статическая инициализация (то есть статические блоки)
Размещение нескольких операторов инициализации в статическую скобку называется статическим блоком. На самом деле, он написан вместе, написав несколько статиков, и сущность одинакова. Выполняется только тогда, когда объект создается в первый раз, или поле класса доступно впервые, и только один раз.
Кубок класса {cup (int marker) {print ("cup (" + marker + ")"); } void f (int marker) {print ("f (" + marker + ")"); }} чашки класса {статическая чашка Cup1; статическая чашка2; статический {cup1 = новая чашка (1); Cup2 = новая чашка (2); } Cups () {print ("cups ()"); }} public class explicitStatic {public static void main (string [] args) {print ("inside main ()"); Cups.cup1.f (99); // (1)} // статические чашки Cups1 = new Cups (); // (2) // статические чашки Cups2 = новые чашки (); // (2)}Выход:
Inside Main () чашка (1) чашка (2) F (99)
Нестатическая инициализация экземпляра
Об этом нечего сказать, это просто обычная инициализация, выполненная по порядку и может быть выполнена несколько раз.
класс Mug {mug (int marker) {print ("mug (" + marker + ")"); } void f (int marker) {print ("f (" + marker + ")"); }} открытый класс Mugs {Mug Mug1; Mug Mug2; {mug1 = новая кружка (1); MUG2 = новая кружка (2); print ("Mug1 & Mug2 инициализирован"); } Mugs () {print ("mugs ()"); } Кружки (int i) {print ("Mugs (int)"); } public static void main (string [] args) {print ("inside main ()"); новые кружки (); print ("new Mugs () завершен"); новые кружки (1); Print («Новые кружки (1) завершены»); }}Inside Main () Mug (1) Mug (2) MUG1 & MUG2 инициализированная mugs () Новые кружки () Завершенные Магист