Ključna reč static

Ključna reč static se u Javi koristi uglavnom za upravljanje memorijom. Može se primeniti na promenljive, metode, blokove i ugnježđene klase. Ključna reč static više pripada klasi nego instanci klase. Statički mogu biti:

Promenljiva (zove se još i klasna promenljiva)
Metoda (zove se još i klasna metoda)
Blok
Ugnježđena klasa

1) Statička promenljiva:

Promenljiva deklarisana pomoću ključne reči static.

Statička promenljiva se može upotrebiti tako da se odnosi na zajedničke osobine svih objekata (osobine koje nisu jedinstvene za svaki objekat), npr.

kompanija – imena zaposlenih;

fakultet – imena studenata,

itd.

Statičkoj promenljivoj se dodeljuje memorija samo jednom u prostoru klase u trenutku učitavanja klase.

Prednosti statičke promenljive: Statička promenljiva čini program memorijski efikasnijim (tj. štedi memoriju). Razumevanje problema bez statičke promenljive





1
2
3
4
5


class Student{
     int brind;
     String ime;
     String fakultet="FTN";
}

Pretpostavimo da na fakultetu ima 500 studenata, pa će sve instancne promenljive dobiti memoriju svaki put kada se objekt kreira. Svaki student ima svoj jedinstveni broj indeksa (brind) i ime tako da je instancna promenljiva dobra. Ovde fakultet označava zajedničku osobinu svih objekata. Ako je učinimo statičkom, ovo će polje dobiti memoriju samo jednom. Napomena 1: Statička osobina se deli na sve objekte. Primer 1:





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


//Program sa statičkom varijablom  
      
    class Student8{  
       int brind;  
       String ime;  
       static String fakultet ="FTN";  
         
       Student8(int r,String n){  
       brind = r;  
       ime = n;  
       }  
     void display (){System.out.println(brind+" "+ime+" "+fakultet);}  
      
     public static void main(String args[]){  
     Student8  s1 = new Student8(111,"Petar");  
     Student8  s2 = new Student8(222,"Marko");  
       
     s1.display();  
     s2.display();  
     }  
    }  

Ispis na ekranu:
111 Petar FTN
222 Marko FTN

Primer 2: Program brojač (counter) bez statičke promenljive. U ovom primeru kreiraćemo instancnu promenljivu imena count koja se inkrementira u konstruktoru. Pošto instansna promenljiva dobija memoriju u trenutku kreiranja objekta, svaki objekat će imati kopiju instancne promenljive, pa ako se inkrementira to se neće odraziti na druge objekte. Tako će svaki objekt imati vrednost 1 u promenljivoj count.





1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20


class Counter{  
  int count=0;          //dobija memoriju kada se instanca kreira  
  
  Counter(){  
  count++;  
  System.out.println(count);  
}  
  
public static void main(String args[]){  
  
  Counter  c1=new Counter();  
  Counter  c2=new Counter();  
  Counter  c3=new Counter();  
  }  
}

Ispis na ekranu:
1
1
1

Primer 3: Program brojač (counter) sa statičkom promenljivom. Kao što je već rečeno, statička promenljiva će dobiti memoriju samo jednom, pa ako bilo koji objekat promeni vrednost statičke promenljive, ona će zadržati tu vrednost.





1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20


class Counter{  
  static int count=0;          //dobija memoriju samo jednom i zadržava svoju vrednost  
  
  Counter(){  
  count++;  
  System.out.println(count);  
}  
  
public static void main(String args[]){  
  
  Counter  c1=new Counter();  
  Counter  c2=new Counter();  
  Counter  c3=new Counter();  
  }  
}

Ispis na ekranu:
1
2
3

2) Statička metoda

Ako primenimo ključnu reč static na bilo koji metod, on postaje statički metod • statički metod pripada klasi a ne objektu klase. • statički metod može biti pozvan bez potrebe da se kreira instanca klase. • statički metod može pristupiti statičkim podacima-članovima i može menjati njihovu vrednost.
Primer statičke metode:





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
33
34
35


//Program koji menja zajedničke osobine svih objekata (statičko polje).  
  
class Student9{  
     int rollno;  
     String name;  
     static String college = "FTN";  
       
     static void change(){  
     college = "FTNinformatika";  
     }  
  
     Student9(int r, String n){  
     rollno = r;  
     name = n;  
     }  
  
     void display (){System.out.println(rollno+" "+name+" "+college);}  
  
    public static void main(String args[]){  
    Student9.change();  
  
    Student9 s1 = new Student9 (111,"Petar");  
    Student9 s2 = new Student9 (222,"Marko");  
    Student9 s3 = new Student9 (333,"Janko");  
  
    s1.display();  
    s2.display();  
    s3.display();  
    }  
}

Ispis na ekranu: 
111 Petar FTNinformatika
222 Marko FTNinformatika
333 Janko FTNinformatika

Drugi primer statičke metode koja vrši normalne kalkulacije





1
2
3
4
5
6
7
8
9
10
11
12
13
14
15


//Program koji računa kub datog broja pomoću statičke metode  
  
class Calculate{  
  static int cube(int x){  
  return x*x*x;  
  }  
  
  public static void main(String args[]){  
  int result=Calculate.cube(5);  
  System.out.println(result);  
  }  
}

Ispis na ekranu:
125

Ograničenja statičkog metoda
Postoje dva glavna ograničenja za statički metod. To su: 1. statički metod ne može koristiti ne-statičke podatke-članove ili pozvati ne-statički metod direktno. 2. this i super se ne mogu koristiti u statičkom kontekstu.





1
2
3
4
5
6
7
8
9
10


class A{  
 int a=40; //ne-statički  
   
 public static void main(String args[]){  
  System.out.println(a);  
 }  
}

Ispis na ekranu:
Compile Time Error

Zašto je main metod statičan?

Zato što objekat ne mora da poziva statički metod; ako bi main bio ne-statički metod, JVM bi prvo kreirao objekt a zatim pozvao main() metod što bi dovelo do problema alokacije dodatne memorije.

3) Statički blok

• Koristi se da inicijalizuje statički podatak-član.
• Izvršava se pre main metode u vremenu učitavanja klase. Primer statičkog bloka:





1
2
3
4
5
6
7
8
9
10
11
12


class A2{  
  
  static{System.out.println("statički blok je pozvan");}  
  
  public static void main(String args[]){  
   System.out.println("Hello main");  
  }  
}

Ispis na ekranu: 
statički blok je pozvan
Hello main

Može li se program izvršiti bez main() metode? Da, jedan od načina je statički blok ali u prethodnoj verziji JDK ,ne od JDK 1.7.





1
2
3
4
5
6
7
8
9
10
11
12
13
14
15


class A3{  
  static{  
  System.out.println("statički blok je pozvan");  
  System.exit(0);  
  }  
}

Ispis na ekranu: 
statički blok je pozvan (ako nije JDK7)

U JDK7 i novijim, izlaz će biti:

Ispis na ekranu:
Error: Main method not found in class A3, please define the main method as:
public static void main(String[] args)

Comments

comments