In questo tutorial, impareremo la parola chiave statica Java insieme a metodi statici, variabili statiche e blocchi statici con l'aiuto di esempi.
Cos'è una parola chiave statica in Java?
In Java, se vogliamo accedere ai membri della classe, dobbiamo prima creare un'istanza della classe. Ma ci saranno situazioni in cui vogliamo accedere ai membri della classe senza creare variabili.
In quelle situazioni, possiamo usare la staticparola chiave in Java. Se vogliamo accedere ai membri della classe senza creare un'istanza della classe, dobbiamo dichiarare i membri della classe statici.
La Mathclasse in Java ha quasi tutti i suoi membri statici. Quindi, possiamo accedere ai suoi membri senza creare istanze della classe Math. Per esempio,
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)); ) )
Uscita :
Valore assoluto di -12 = 12 Valore di PI = 3,141592653589793 Valore di E = 2,718281828459045 2 2 = 4,0
Nell'esempio precedente, non abbiamo creato alcuna istanza della Mathclasse. Ma siamo in grado di accedere ai suoi metodi: abs()e pow()e variabili: PIe E.
È possibile perché i metodi e le variabili della Mathclasse sono statici.
Metodi statici
I metodi statici sono anche chiamati metodi di classe. È perché un metodo statico appartiene alla classe piuttosto che all'oggetto di una classe.
E possiamo invocare metodi statici direttamente usando il nome della classe. Per esempio,
class Test ( // static method inside the Test class public static void method() (… ) ) class Main ( // invoking the static method Test.method(); )
Qui, possiamo vedere che è possibile accedere al metodo statico direttamente da altre classi utilizzando il nome della classe.
In ogni programma Java, abbiamo dichiarato il mainmetodo static. È perché per eseguire il programma la JVM dovrebbe essere in grado di richiamare il metodo principale durante la fase iniziale in cui non esistono oggetti nella memoria.
Esempio 1: metodi Java statici e non statici
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)); ) )
Uscita :
2 * 2 = 4 2 + 3 = 5
Nel programma precedente, abbiamo dichiarato un metodo non statico denominato multiply()e un metodo statico denominato add()all'interno della classe StaticTest.
All'interno della classe Main, possiamo vedere che stiamo chiamando il metodo non statico utilizzando l'oggetto della classe ( st.multiply(2, 2)). Tuttavia, stiamo chiamando il metodo statico utilizzando il nome della classe ( StaticTest.add(2, 3)).
Variabili statiche
In Java, quando creiamo oggetti di una classe, ogni oggetto avrà la propria copia di tutte le variabili della classe. Per esempio,
class Test ( // regular variable int age; ) class Main ( // create instances of Test Test test1 = new Test(); Test test2 = new Test(); )
In questo caso, entrambi gli oggetti test1 e test2 avranno copie separate della variabile age. E sono diversi l'uno dall'altro.
Tuttavia, se dichiariamo una variabile statica, tutti gli oggetti della classe condividono la stessa variabile statica. È perché, come i metodi statici, anche le variabili statiche sono associate alla classe. E non abbiamo bisogno di creare oggetti della classe per accedere alle variabili statiche. Per esempio,
class Test ( // static variable static int age; ) class Main ( // access the static variable Test.age = 20; )
Qui, possiamo vedere che stiamo accedendo alla variabile statica dall'altra classe utilizzando il nome della classe.
Esempio 2: variabili Java statiche e non statiche
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)); ) )
Uscita :
min + 1 = 6 max + 1 = 11
Nel programma precedente, abbiamo dichiarato una variabile non statica denominata min e una variabile statica denominata max all'interno della classe Test.
All'interno della classe Main, possiamo vedere che stiamo chiamando la variabile non statica utilizzando l'oggetto della classe ( obj.min + 1). Tuttavia, stiamo chiamando la variabile statica utilizzando il nome della classe ( Test.max + 1).
Nota : le variabili statiche vengono utilizzate raramente in Java. Vengono invece utilizzate le costanti statiche. Queste costanti statiche sono definite dalla static finalparola chiave e rappresentate in maiuscolo. Questo è il motivo per cui alcune persone preferiscono usare le maiuscole anche per le variabili statiche.
Accedi a variabili e metodi statici all'interno della classe
Stiamo accedendo alla variabile statica da un'altra classe. Quindi, abbiamo usato il nome della classe per accedervi. Tuttavia, se vogliamo accedere al membro statico dall'interno della classe, è possibile accedervi direttamente. Per esempio,
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(); ) )
Uscita :
L'età è 30 Metodo statico
Qui, siamo in grado di accedere direttamente alla variabile statica e al metodo senza utilizzare il nome della classe. È perché le variabili ei metodi statici sono pubblici per impostazione predefinita. E, poiché stiamo accedendo dalla stessa classe, non dobbiamo specificare il nome della classe.
Blocchi statici
In Java, i blocchi statici vengono utilizzati per inizializzare le variabili statiche. Per esempio,
class Test ( // static variable static int age; // static block static ( age = 23; ) )
Qui possiamo vedere che abbiamo utilizzato un blocco statico con la sintassi:
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 blockis printed and the value of b is set toa * 4. - The second static block is executed. Hence, the string
Second Static blockis printed and the value of max is set to30. - Infine,
display()vengono eseguite le istruzioni print all'interno del metodo .
Classe statica annidata
In Java, possiamo dichiarare una classe all'interno di un'altra classe. Tali classi sono note come classi annidate. Le classi annidate sono di 2 tipi:
- Classi annidate statiche
- Classi annidate non statiche
Per esempio,
class OuterClass ( // static nested class static class NestedClass (… ) // non-static nested class class InnerClass (… ) )
Per saperne di più, visita la Java Nested Class.
