V tomto tutoriálu se pomocí příkladů seznámíme s klíčovým slovem Java static a statickými metodami, statickými proměnnými a statickými bloky.
Co je statické klíčové slovo v Javě?
Pokud chceme v Javě přistupovat ke členům třídy, musíme nejprve vytvořit instanci třídy. Budou ale situace, kdy chceme přistupovat ke členům třídy bez vytváření jakýchkoli proměnných.
V takových situacích můžeme použít static
klíčové slovo v Javě. Pokud chceme přistupovat ke členům třídy bez vytvoření instance třídy, musíme deklarovat členy třídy statické.
Math
Třída v Javě má téměř všichni její členové statické. Takže můžeme přistupovat k jeho členům bez vytváření instancí třídy Math. Napří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 :
Absolutní hodnota -12 = 12 Hodnota PI = 3,141592653589793 Hodnota E = 2,718281828459045 2 2 = 4,0
Ve výše uvedeném příkladu jsme nevytvořili žádné instance Math
třídy. Ale jsme schopni přistupovat k jeho metodám: abs()
a pow()
a proměnným: PI
a E
.
Je to možné, protože metody a proměnné Math
třídy jsou statické.
Statické metody
Statické metody se také nazývají třídní metody. Je to proto, že statická metoda patří spíše do třídy než do předmětu třídy.
A můžeme vyvolat statické metody přímo pomocí názvu třídy. Například,
class Test ( // static method inside the Test class public static void method() (… ) ) class Main ( // invoking the static method Test.method(); )
Zde vidíme, že ke statické metodě lze přistupovat přímo z jiných tříd pomocí názvu třídy.
V každém programu Java jsme deklarovali main
metodu static
. Je to proto, že ke spuštění programu by měl JVM být schopen vyvolat hlavní metodu během počáteční fáze, kdy v paměti neexistují žádné objekty.
Příklad 1: Java statické a nestatické metody
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
Ve výše uvedeném programu jsme deklarovali nestatickou metodu s názvem multiply()
a statickou metodu pojmenovanou add()
uvnitř třídy StaticTest
.
Uvnitř hlavní třídy vidíme, že voláme nestatickou metodu pomocí objektu třídy ( st.multiply(2, 2)
). Voláme však statickou metodu pomocí názvu třídy ( StaticTest.add(2, 3)
).
Statické proměnné
Když v Javě vytváříme objekty třídy, pak každý objekt bude mít vlastní kopii všech proměnných třídy. Například,
class Test ( // regular variable int age; ) class Main ( // create instances of Test Test test1 = new Test(); Test test2 = new Test(); )
Zde budou mít objekty test1 i test2 samostatné kopie proměnného stáří. A navzájem se liší.
Pokud však deklarujeme proměnnou statickou, všechny objekty třídy sdílejí stejnou statickou proměnnou. Je to proto, že stejně jako statické metody jsou ke třídě přidruženy také statické proměnné. Pro přístup ke statickým proměnným nepotřebujeme vytvářet objekty třídy. Například,
class Test ( // static variable static int age; ) class Main ( // access the static variable Test.age = 20; )
Zde vidíme, že přistupujeme ke statické proměnné z jiné třídy pomocí názvu třídy.
Příklad 2: Statické a nestatické proměnné Java
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
Ve výše uvedeném programu jsme deklarovali nestatickou proměnnou s názvem min a statickou proměnnou s názvem max uvnitř třídy Test.
Uvnitř třídy Main vidíme, že voláme nestatickou proměnnou pomocí objektu třídy ( obj.min + 1
). Voláme však statickou proměnnou pomocí názvu třídy ( Test.max + 1
).
Poznámka : Statické proměnné se v Javě používají jen zřídka. Místo toho se používají statické konstanty. Tyto statické konstanty jsou definovány static final
klíčovým slovem a reprezentovány velkými písmeny. Proto někteří lidé raději používají velká písmena i pro statické proměnné.
Přistupujte ke statickým proměnným a metodám ve třídě
Přistupujeme ke statické proměnné z jiné třídy. Proto jsme k přístupu použili název třídy. Pokud však chceme získat přístup ke statickému členovi zevnitř třídy, lze k němu přistupovat přímo. Napří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 :
Věk je 30 statická metoda
Tady jsme schopni přistupovat ke statické proměnné a metodě přímo bez použití názvu třídy. Je to proto, že statické proměnné a metody jsou ve výchozím nastavení veřejné. A protože přistupujeme ze stejné třídy, nemusíme specifikovat název třídy.
Statické bloky
V Javě se statické bloky používají k inicializaci statických proměnných. Například,
class Test ( // static variable static int age; // static block static ( age = 23; ) )
Zde vidíme, že jsme použili statický blok se syntaxí:
static ( // variable initialization )
The static block is executed only once when the class is loaded in memory. The class is loaded if either the object of the class is requested in code or the static members are requested in code.
A class can have multiple static blocks and each static block is executed in the same sequence in which they have been written in a program.
Example 3: Use of static block in java
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(); ) )
Output:
First Static block. Second Static block. a = 23 b = 92 max = 30
In the above program. as soon as the Main class is loaded,
- The value of a is set to
23
. - The first static block is executed. Hence, the string
First Static block
is printed and the value of b is set toa * 4
. - The second static block is executed. Hence, the string
Second Static block
is printed and the value of max is set to30
. - A nakonec
display()
se provedou tiskové příkazy uvnitř metody .
Vnořená statická třída
V Javě můžeme deklarovat třídu uvnitř jiné třídy. Takové třídy jsou známé jako vnořené třídy. Vnořené třídy jsou 2 typů:
- Statické vnořené třídy
- Nestatické vnořené třídy
Například,
class OuterClass ( // static nested class static class NestedClass (… ) // non-static nested class class InnerClass (… ) )
Chcete-li se dozvědět více, navštivte třídu Java Nested.