SCJP - Bloki inicjalizacyjne

Dziś będzie o blokach inicjalizacyjnych (ang. initialization blocks). Kolejny kroczek w ciągnących się przygotowaniach do SCJP zapowiedzianych w artykule "Przygotowania do SCJP czas zacząć".

Bloki inicjalizacyjne występują w dwu rodzajach: jako bloki instancyjne i bloki statyczne. Blok inicjalizacyjny to fragment kodu, który wykonuje się – w przypadku bloków statycznych – gdy ładowana jest klasa, bądź – w przypadku bloków instancyjnych – gdy tworzona jest instancja. Zerknijmy na poniższy przykład.

public class Test {
    public Test() {
        System.out.println("constructor");
    }
 
    static {
        System.out.println("static init block");
    }
 
    {
        System.out.println("instance init block");
    }
 
    public static void main(String[] args) {
        System.out.println("start main");
 
        Test test = new Test();
         
        System.out.println("end main");
    }
}

Kod znajdujący się między konstruktorem a metodą ‘main(…)’ to właśnie bloki inicjalizacyjne. Ten oznaczony słówkiem kluczowym ‘static’ to blok statyczny. Ten drugi to blok instancji. Bloki statyczne – jak już powiedzieliśmy – wykonywane są w momencie ładowania klasy a więc zawsze jest to kod, który wykona się jako pierwszy. O blokach instancyjnych powiedzieliśmy sobie, że wykonują się w momencie tworzenia instancji, ale w momencie tworzenia instancji klasy wykonują się też konstruktory. Jaka jest zatem kolejność? Wpierw konstruktor czy blok inicjalizacyjny? Otóż ani to, ani to. Jak pisałem w artykule "SCJP - Konstruktory i inicjalizacja" pierwszą instrukcją konstruktora jest zawsze wywołanie konstruktora nadklasy albo innego konstruktora tej samej klasy. Właśnie zaraz po tym wywołaniu – przed wykonaniem jakiejkolwiek innej instrukcji konstruktora – wykonywany jest kod bloków inicjalizacyjnych instancji. Efekt uruchomienia powyższego programu będzie zatem taki:

static init block
start main
instance init block
constructor
end main

W poprzednim akapicie pisałem o blokach inicjalizacyjnych w liczbie mnogiej i bynajmniej nie był to mój błąd. W każdej klasie może występować dowolna ilość bloków inicjalizacyjnych. O kolejności ich wykonania decyduje kolejność w jakiej są one zapisane, patrząc od góry do dołu. Spójrzmy na kolejny przykład.

class SuperClass {
    public SuperClass() {
        System.out.println("superclass constructor");
    }
 
    {
        System.out.println("superclass instance init block");
    }
}
 
public class Test extends SuperClass {
    public Test() {
        System.out.println("constructor");
    }
 
    static {
        System.out.println("static init block");
    }
 
    {
        System.out.println("instance init block #1");
    }
 
    {
        System.out.println("instance init block #2");
    }
 
    public static void main(String[] args) {
        Test test = new Test();
    }
}

Jak widzimy pojawiła się większa ilość bloków inicjalizacyjnych oraz nadklasa. Przekonajmy się, że kolejność wywoływania kodu bloków inicjalizacyjnych versus konstruktory jest taka właśnie jak to opisałem. Uruchomienie tego programu spowoduje wypisanie następującej sekwencji.

static init block
superclass instance init block
superclass constructor
instance init block #1
instance init block #2
constructor

A co się stanie, jeśli kod bloku inicjalizującego spowoduje wyjątek, np. odwołamy się do niewłaściwego indeksu tablicy? Naturalnie wyjątek zostanie zwrócony… w postaci opakowanej w java.lang.ExceptionInInitializerError.