Blok inicijalizator instance / Non-static instance initialization

by
Blok inicijalizator instance se koristi da inicijalizuje podatak-član instance. On se pokreće svaki put kada se kreira objekat klase. Inicijalizacija instancne promenljive može biti direktna, ali moguće je izvršiti i neke dodatne operacije prilikom inicijalizovanja instancne promenljive u bloku inicijalizatoru instance. Zašto se koristi blok inicijalizator instance? Znamo da je moguće direktno dodeliti vrednost podatku-članu instance. Npr.
1
2
3
class Bike{ 
    int speed=100; 
}
Pretpostavimo da moramo izvršiti neke operacije prilikom dodeljivanja vrednosti podatku-članu instance, npr. for petlju koja će popuniti neki kompleksni niz ili rukovanje greškama itd. Primer bloka inicijalizatora instance: Pogledajmo jednostavan primer bloka inicijalizatora instance koji izvršava inicijalizaciju
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Bike7{ 
    int speed; 
      
    Bike7(){System.out.println("brzina je "+speed);} 
   
    {speed=100;} 
       
    public static void main(String args[]){ 
    Bike7 b1=new Bike7(); 
    Bike7 b2=new Bike7(); 
    }     
}
Ispis na ekranu:
brzina je 100
      brzina je 100
Postoje tri mesta u Javi gde se mogu izvoditi operacije: 1. metoda 2. konstruktor 3. blok Da li se prvo poziva blok inicijalizator instance ili konstruktor?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class Bike8{ 
    int speed; 
      
    Bike8(){System.out.println("konstruktor je pozvan");} 
   
    {System.out.println("blok inicijalizator instance je pozvan");} 
       
    public static void main(String args[]){ 
    Bike8 b1=new Bike8(); 
    Bike8 b2=new Bike8(); 
    }     
}
Ispis na ekranu:
blok inicijalizator instance je pozvan
       konstruktor je pozvan
       blok inicijalizator instance je pozvan
       konstruktor je pozvan
U ovom primeru, izgleda kao da je blok inicijalizator instance prvi pozvan, ali zapravo nije. Blok inicijalizator instance je pozvan u vreme kreiranja objekta. Java kompajler kopira blok inicijalizator instance u konstruktor nakon prve naredbe super(). Tako je prvo pozvan konstruktor. Ovo je pokazano na sledećoj slici: Napomena: Java kompajler kopira kod bloka inicijalizatora instance u svaki konstruktor. Pravila za blok inicijalizator instance: Postoje uglavnom tri pravila za blok inicijalizator instance. To su:
  1. Blok inicijalizator instance je kreiran kada je kreirana instanca klase.
  2. Blok inicijalizator instance se poziva nakon što je pozvan konstruktor roditeljske klase (napr. nakon poziva super() konstruktora).
  3. Blok inicijalizator instance dolazi po redu po kome se pojavljuje.
Primer 1: blok inicijalizator instance koji se poziva nakon super()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class A{ 
  A(){ 
    System.out.println("pozvan je konstruktor roditeljske klase"); 
  } 
}
  
class B2 extends A{ 
  B2(){ 
  super(); 
  System.out.println("pozvan je konstruktor klase-djeteta"); 
} 
  
{System.out.println("pozvan je blok inicijalizator instance");} 
  
  public static void main(String args[]){ 
    B2 b=new B2(); 
  } 
}
Ispis na ekranu:
pozvan je konstruktor roditeljske klase
Blok inicijalizator instance
pozvan je konstruktor klase-deteta
Primer 2:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
class A{ 
A(){ 
System.out.println("pozvan je konstruktor roditeljske klase"); 
} 
} 
class B3 extends A{ 
B3(){ 
super(); 
System.out.println("pozvan je konstruktor klase-deteta"); 
} 
B3(int a){ 
super(); 
System.out.println("pozvan je konstruktor klase-deteta"+a); 
} 
{System.out.println("pozvan je blok inicijalizator instance");} 
public static void main(String args[]){ 
B3 b1=new B3(); 
B3 b2=new B3(10); 
} 
}
Ispis na ekranu:
pozvan je konstruktor roditeljske klase
Blok inicijalizator instance
pozvan je konstruktor klase-deteta
pozvan je konstruktor roditeljske klase
Blok inicijalizator instance
pozvan je konstruktor klase-deteta 10
a na engleskom:

Non-static instance initialization

 Java provides instance initialization for initializing non-static variables for each object. Here’s an example: //: initialization/Mugs.java // Java “Instance Initialization.” import static net.mindview.util.Print.*; class Mug { Mug(int marker) { print(“Mug(” + marker + “)”); } void f(int marker) { print(“f(” + marker + “)”); } } public class Mugs { Mug mug1; Mug mug2; { mug1 = new Mug(1); mug2 = new Mug(2); print(“mug1 & mug2 initialized”); } Mugs() { print(“Mugs()”); } Mugs(int i) { print(“Mugs(int)”); } public static void main(String[] args) { print(“Inside main()”); new Mugs(); print(“new Mugs() completed”); new Mugs(1); print(“new Mugs(1) completed”); } } /* Output: Inside main() Mug(1) Mug(2) mug1 & mug2 initialized Mugs() new Mugs() completed Mug(1) Mug(2) mug1 & mug2 initialized Mugs(int) new Mugs(1) completed *///:~ You can see that the instance initialization clause: { 132 Thinking in Java Bruce Eckel mug1 = new Mug(1); mug2 = new Mug(2); print(“mug1 & mug2 initialized”); } looks exactly like the static initialization clause except for the missing static keyword. This syntax is necessary to support the initialization of anonymous inner classes (see the Inner Classes chapter), but it also allows you to guarantee that certain operations occur regardless of which explicit constructor is called. From the output, you can see that the instance initialization clause is executed before either one of the constructors.

Comments

comments