V tomto tutoriáli sa pomocou príkladov dozvieme o statickom kľúčovom slove Java spolu so statickými metódami, statickými premennými a statickými blokmi.
Čo je statické kľúčové slovo v Jave?
Ak chceme v Jave získať prístup k členom triedy, musíme najskôr vytvoriť inštanciu triedy. Ale budú situácie, keď chceme získať prístup k členom triedy bez vytvárania akýchkoľvek premenných.
V týchto situáciách môžeme static
kľúčové slovo použiť v prostredí Java. Ak chceme získať prístup k členom triedy bez vytvorenia inštancie triedy, musíme členov triedy vyhlásiť za statický.
Math
Trieda v Jave má takmer všetci jej členovia statické. Môžeme teda pristupovať k jej členom bez vytvárania inštancií triedy Math. Napríklad,
public class Main ( public static void main( String() args ) ( // accessing the methods of the Math class System.out.println("Absolute value of -12 = " + Math.abs(-12)); System.out.println("Value of PI = " + Math.PI); System.out.println("Value of E = " + Math.E); System.out.println("2^2 = " + Math.pow(2,2)); ) )
Výstup :
Absolútna hodnota -12 = 12 Hodnota PI = 3,141592653589793 Hodnota E = 2,718281828459045 2 2 = 4,0
Vo vyššie uvedenom príklade sme nevytvorili žiadne inštancie Math
triedy. Ale sme schopní získať prístup k jeho metódam: abs()
a pow()
a premenným: PI
a E
.
Je to možné, pretože metódy a premenné Math
triedy sú statické.
Statické metódy
Statickým metódam sa hovorí aj triedne metódy. Je to tak preto, lebo statická metóda patrí skôr do triedy ako do triedy.
A môžeme vyvolať statické metódy priamo pomocou názvu triedy. Napríklad,
class Test ( // static method inside the Test class public static void method() (… ) ) class Main ( // invoking the static method Test.method(); )
Tu vidíme, že ku statickej metóde je možné pristupovať priamo z iných tried pomocou názvu triedy.
V každom programe Java sme deklarovali main
metódu static
. Je to preto, že na spustenie programu by JVM malo byť schopné vyvolať hlavnú metódu počas počiatočnej fázy, keď v pamäti neexistujú žiadne objekty.
Príklad 1: Java statické a nestatické metódy
class StaticTest ( // non-static method int multiply(int a, int b)( return a * b; ) // static method static int add(int a, int b)( return a + b; ) ) public class Main ( public static void main( String() args ) ( // create an instance of the StaticTest class StaticTest st = new StaticTest(); // call the nonstatic method System.out.println(" 2 * 2 = " + st.multiply(2,2)); // call the static method System.out.println(" 2 + 3 = " + StaticTest.add(2,3)); ) )
Výstup :
2 * 2 = 4 2 + 3 = 5
Vo vyššie uvedenom programe sme deklarovali nestatickú metódu s názvom multiply()
a statickú metódu pomenovanú add()
vo vnútri triedy StaticTest
.
Vo vnútri hlavnej triedy vidíme, že voláme nestatickú metódu pomocou objektu triedy ( st.multiply(2, 2)
). Statickú metódu však voláme pomocou názvu triedy ( StaticTest.add(2, 3)
).
Statické premenné
Keď v Jave vytvoríme objekty triedy, potom bude mať každý objekt svoju vlastnú kópiu všetkých premenných triedy. Napríklad,
class Test ( // regular variable int age; ) class Main ( // create instances of Test Test test1 = new Test(); Test test2 = new Test(); )
Tu budú mať objekty test1 aj test2 samostatné kópie premenného veku. A navzájom sa líšia.
Ak však deklarujeme premennú statickú, všetky objekty triedy zdieľajú rovnakú statickú premennú. Je to preto, že rovnako ako statické metódy, aj statické premenné sú spojené s triedou. Na prístup k statickým premenným nepotrebujeme vytvárať objekty triedy. Napríklad,
class Test ( // static variable static int age; ) class Main ( // access the static variable Test.age = 20; )
Tu vidíme, že pristupujeme k statickej premennej z druhej triedy pomocou názvu triedy.
Príklad 2: Java statické a nestatické premenné
class Test ( // static variable static int max = 10; // non-static variable int min = 5; ) public class Main ( public static void main(String() args) ( Test obj = new Test(); // access the non-static variable System.out.println("min + 1 = " + (obj.min + 1)); // access the static variable System.out.println("max + 1 = " + (Test.max + 1)); ) )
Výstup :
min. + 1 = 6 max. + 1 = 11
Vo vyššie uvedenom programe sme vnútri triedy Test deklarovali nestatickú premennú s názvom min a statickú premennú s názvom max.
Vo vnútri hlavnej triedy vidíme, že voláme nestatickú premennú pomocou objektu class ( obj.min + 1
). Statickú premennú však voláme pomocou názvu triedy ( Test.max + 1
).
Poznámka : Statické premenné sa v Jave používajú zriedka. Namiesto toho sa použijú statické konštanty. Tieto statické konštanty sú definované static final
kľúčovým slovom a zobrazené veľkými písmenami. Preto niektorí ľudia radšej používajú veľké písmená aj pre statické premenné.
Prístup k statickým premenným a metódam v rámci triedy
K statickej premennej pristupujeme z inej triedy. Preto sme na prístup použili názov triedy. Ak však chceme získať prístup k statickému členovi zvnútra triedy, je k nemu možný priamy prístup. Napríklad,
public class Main ( // static variable static int age; // static method static void display() ( System.out.println("Static Method"); ) public static void main(String() args) ( // access the static variable age = 30; System.out.println("Age is " + age); // access the static method display(); ) )
Výstup :
Vek je 30 statická metóda
Tu máme prístup k statickej premennej a metóde priamo bez použitia názvu triedy. Je to tak preto, lebo statické premenné a metódy sú predvolene verejné. A keďže pristupujeme z rovnakej triedy, nemusíme špecifikovať názov triedy.
Statické bloky
V Jave sa statické bloky používajú na inicializáciu statických premenných. Napríklad,
class Test ( // static variable static int age; // static block static ( age = 23; ) )
Tu vidíme, že sme použili statický blok so syntaxou:
static ( // variable initialization )
Statický blok sa vykoná iba raz, keď je trieda načítaná do pamäte. Trieda sa načíta, ak sa v kóde požaduje objekt triedy alebo sa v kóde požadujú statické členy.
Trieda môže mať viac statických blokov a každý statický blok sa vykonáva v rovnakom poradí, v akom boli napísané v programe.
Príklad 3: Použitie statického bloku v jave
class Main ( // static variables static int a = 23; static int b; static int max; // static blocks static ( System.out.println("First Static block."); b = a * 4; ) static ( System.out.println("Second Static block."); max = 30; ) // static method static void display() ( System.out.println("a = " + a); System.out.println("b = " + b); System.out.println("max = " + max); ) public static void main(String args()) ( // calling the static method display(); ) )
Výstup :
Prvý statický blok. Druhý statický blok. a = 23 b = 92 max = 30
Vo vyššie uvedenom programe. hneď ako sa načíta hlavná trieda,
- Hodnota a je nastavená na
23
. - Prvý statický blok je vykonaný. Preto je reťazec
First Static block
vytlačený a hodnota b je nastavená naa * 4
. - Vykoná sa druhý statický blok. Preto je reťazec
Second Static block
vytlačený a hodnota max je nastavená na30
. - A nakoniec
display()
sa vykonajú tlačové príkazy vo vnútri metódy .
Vnorená statická trieda
V Jave môžeme triedu vyhlásiť v inej triede. Takéto triedy sú známe ako vnorené triedy. Vnorené triedy sú 2 typov:
- Statické vnorené triedy
- Nestatické vnorené triedy
Napríklad,
class OuterClass ( // static nested class static class NestedClass (… ) // non-static nested class class InnerClass (… ) )
Ak sa chcete dozvedieť viac, navštívte triedu Java Nested.