Inicjalizacja statyczna w Javie

Uff! czym jest inicjalizacja statyczna?

Inicjalizacja statyczna jest static {} blokiem kodu wewnątrz klasy java i jest uruchamiana tylko jeden raz przed wywołaniem konstruktora lub głównej metody.

OK! Powiedz mi więcej...

• jest blokiem kodu static { ... } wewnątrz dowolnej klasy java. i wykonywane przez maszynę wirtualną po wywołaniu klasy.
• żadne return instrukcje nie są obsługiwane.
• żadne argumenty nie są wspierane.
• nie this lub super są obsługiwane.

Hmm gdzie mogę go użyć?

Może być używany wszędzie, gdzie czujesz się dobrze :) to proste. Ale widzę, że większość czasu jest używany podczas wykonywania połączenia z bazą danych, API init, logowania i itp.

Nie szczekaj! gdzie jest przykład?

package com.example.learnjava;

import java.util.ArrayList;

public class Fruit {

    static {
        System.out.println("Inside Static Initializer.");

        // fruits array
        ArrayList<String> fruits = new ArrayList<>();
        fruits.add("Apple");
        fruits.add("Orange");
        fruits.add("Pear");

        // print fruits
        for (String fruit : fruits) {
            System.out.println(fruit);
        }
        System.out.println("End Static Initializer.\n");
    }

    public static void main(String[] args) {
        System.out.println("Inside Main Method.");
    }
}

Wyjście???

Wewnątrz Statycznego Inicjalizatora.

Jabłko

Pomarańczowy

Gruszka

Zakończ Inicjalizację Statyczną.

Inside Main Metoda.

Blok static jest "inicjalizatorem statycznym".

Jest wywoływana automatycznie, gdy klasa jest ładowana i nie ma innego sposobu na jej wywołanie(nawet przez odbicie).

class JNIGlue {
    static {
        System.loadLibrary("foo");
    }
}

To jest bezpośrednio z http://www.programcreek.com/2011/10/java-class-instance-initializers/

1. Zlecenie Wykonania

Spójrz na następujące zajęcia, czy wiesz, która z nich zostanie wykonana pierwsza?

public class Foo {

    //instance variable initializer
    String s = "abc";

    //constructor
    public Foo() {
        System.out.println("constructor called");
    }

    //static initializer
    static {
        System.out.println("static initializer called");
    }

    //instance initializer
    {
        System.out.println("instance initializer called");
    }

    public static void main(String[] args) {
        new Foo();
        new Foo();
    }
}

Wyjście:

Inicjalizator statyczny o nazwie

Inicjalizacja instancji o nazwie

Konstruktor zwany

Inicjalizacja instancji o nazwie

Konstruktor zwany

2. Jak zrobić instancję Java inicjalizator działa?

Przykład inicjujący powyżej zawiera instrukcję println. Aby zrozumieć, jak to działa, możemy traktować to jako instrukcję przypisania zmiennej, np. b = 0. Może to sprawić, że bardziej oczywiste będzie zrozumienie.

Zamiast

int b = 0, możesz napisać

int b;
b = 0;

Dlatego inicjalizatory instancji i inicjalizatory zmiennych instancji są prawie takie same.

3. Kiedy inicjalizatory instancji są przydatne?

Użycie inicjalizatorów instancji jest rzadko, ale nadal może być użyteczną alternatywą dla inicjalizatorów zmiennych instancji, Jeśli:

1. Kod inicjujący musi obsługiwać wyjątki
2. wykonaj obliczenia, których nie można wyrazić za pomocą inicjalizatora zmiennej instancji.

Oczywiście, taki kod można zapisać w konstruktorach. Ale jeśli klasa ma wiele konstruktorów, będziesz musiał powtórzyć kod w każdym konstruktorze.

Z inicjalizatorem instancji, możesz po prostu napisać kod raz, a to być wykonywane bez względu na to, jaki konstruktor zostanie użyty do wytworzenia obiektu. (Myślę, że to tylko pojęcie i nie jest często używane.)

Innym przypadkiem, w którym inicjalizatory instancji są użyteczne, są anonimowe klasy wewnętrzne, które nie mogą deklarować żadnych konstruktorów. (Czy to będzie dobre miejsce na umieszczenie funkcji logowania?)

Należy również zauważyć, że anonimowe klasy implementujące interfejsy [1] nie mają konstruktorów. Dlatego inicjalizatory instancji są potrzebne do wykonywanie dowolnych wyrażeń w czasie budowy.

"final" gwarantuje, że zmienna musi być zainicjalizowana przed końcem kodu inicjującego obiekt. Podobnie" static final " gwarantuje, że zmienna zostanie zainicjalizowana przez koniec kodu inicjalizacyjnego klasy. Pominięcie "static" w kodzie inicjalizacyjnym zamienia go w kod inicjalizacyjny obiektu; w ten sposób zmienna nie spełnia już swoich gwarancji.

Nie będziesz zapisywał kodu do statycznego bloku, który musi być wywoływany w dowolnym miejscu Twojego programu. Jeśli celem kodu jest wywołanie, musisz umieścić go w metodzie.

Możesz pisać statyczne bloki inicjalizacji, aby zainicjować statyczne zmienne, gdy klasa jest ładowana, ale ten kod może być bardziej złożony..

Statyczny blok inicjalizacji wygląda jak metoda bez nazwy, bez argumentów i bez typu zwracanego. Skoro nigdy tego nie nazywasz, to nie potrzebuje imienia. Jedyny raz jego wywołane jest, gdy maszyna wirtualna ładuje klasę.

Gdy programista używa bloku inicjalizatora, kompilator Javy kopiuje inicjalizator do każdego konstruktora bieżącej klasy.

Przykład:

Następujący kod:

class MyClass {

    private int myField = 3;
    {
        myField = myField + 2;
        //myField is worth 5 for all instance
    }

    public MyClass() {
        myField = myField * 4;
        //myField is worth 20 for all instance initialized with this construtor
    }

    public MyClass(int _myParam) {
        if (_myParam > 0) {
            myField = myField * 4;
            //myField is worth 20 for all instance initialized with this construtor
            //if _myParam is greater than 0
        } else {
            myField = myField + 5;
            //myField is worth 10 for all instance initialized with this construtor
            //if _myParam is lower than 0 or if _myParam is worth 0
        }
    }

    public void setMyField(int _myField) {
        myField = _myField;
    }


    public int getMyField() {
        return myField;
    }
}

public class MainClass{

    public static void main(String[] args) {
        MyClass myFirstInstance_ = new MyClass();
        System.out.println(myFirstInstance_.getMyField());//20
        MyClass mySecondInstance_ = new MyClass(1);
        System.out.println(mySecondInstance_.getMyField());//20
        MyClass myThirdInstance_ = new MyClass(-1);
        System.out.println(myThirdInstance_.getMyField());//10
    }
}

Jest równoważne:

class MyClass {

    private int myField = 3;

    public MyClass() {
        myField = myField + 2;
        myField = myField * 4;
        //myField is worth 20 for all instance initialized with this construtor
    }

    public MyClass(int _myParam) {
        myField = myField + 2;
        if (_myParam > 0) {
            myField = myField * 4;
            //myField is worth 20 for all instance initialized with this construtor
            //if _myParam is greater than 0
        } else {
            myField = myField + 5;
            //myField is worth 10 for all instance initialized with this construtor
            //if _myParam is lower than 0 or if _myParam is worth 0
        }
    }

    public void setMyField(int _myField) {
        myField = _myField;
    }


    public int getMyField() {
        return myField;
    }
}

public class MainClass{

    public static void main(String[] args) {
        MyClass myFirstInstance_ = new MyClass();
        System.out.println(myFirstInstance_.getMyField());//20
        MyClass mySecondInstance_ = new MyClass(1);
        System.out.println(mySecondInstance_.getMyField());//20
        MyClass myThirdInstance_ = new MyClass(-1);
        System.out.println(myThirdInstance_.getMyField());//10
    }
}

Mam nadzieję, że mój przykład zostanie zrozumiany przez deweloperów.

Statyczny blok kodu może być użyty do tworzenia instancji lub inicjalizacji zmiennych klasy (w przeciwieństwie do zmiennych obiektu). Deklarowanie statyczne" a " oznacza, że jest to tylko jedno wspólne dla wszystkich obiektów testowych, a statyczny blok kodu inicjalizuje "a" tylko raz, gdy Klasa testowa jest ładowana po raz pierwszy, bez względu na to, ile obiektów testowych zostało utworzonych.

Słowo kluczowe statyczne może być używane z klasą, zmienną, metodą i blokiem. Członkowie statyczni należą do klasy, a nie do konkretnej instancji, co oznacza, że jeśli uczynisz członka statycznym, możesz uzyskać do niego dostęp bez obiektu. Przykład:

Tutaj mamy statyczną metodę myStatic (), możemy wywołać tę metodę bez żadnego obiektu, ponieważ kiedy uczynimy member statycznym, staje się on poziomem klasy. Jeśli usuniemy słowo kluczowe static i uczynimy je niestatycznymi, musimy stworzyć obiekt klasy, aby call it

Statyczne elementy są wspólne dla wszystkich instancji (obiektów) klasy, ale niestatyczne elementy są oddzielne dla każdej instancji klasy.

class SimpleStaticExample {
//static method
static void myStatic()
{
    System.out.println("my Static Method");
}

public static void main(String[] args)
{
      /* You can see that we are calling this
       * method without creating any object. 
       */
       myStatic();
 }
}

Wyjście: moja metoda statyczna