Statické klíčové slovo Java (s příklady)

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 staticklíč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é.

MathTří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 Mathtřídy. Ale jsme schopni přistupovat k jeho metodám: abs()a pow()a proměnným: PIa E.

Je to možné, protože metody a proměnné Mathtří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 mainmetodu 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 finalklíč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 to a * 4.
  • The second static block is executed. Hence, the string Second Static block is printed and the value of max is set to 30.
  • 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.

Zajímavé články...