parola chiave statica in java

Tutorial

Java

La parola chiave statica in Java viene utilizzata molto nella programmazione Java. La parola chiave statica in Java viene utilizzata per creare una variabile di livello di classe in Java. Le variabili statiche e i metodi fanno parte della classe, non delle istanze della classe.

La parola chiave statica in Java

Java static la parola chiave può essere utilizzata in cinque casi come mostrato nell’immagine sottostante. Discuteremo quattro di essi qui, il quinto è stato introdotto in Java 8 e ne è stata discussa in Java 8 modifiche all’interfaccia.

Variabile statica Java

Possiamo utilizzare la parola chiave static con una variabile di livello di classe. Una variabile statica è una variabile di classe e non appartiene all’oggetto/istanza della classe. Poiché le variabili statiche sono condivise tra tutte le istanze dell’oggetto, non sono thread safe. Di solito, le variabili statiche vengono utilizzate con la parola chiave final per risorse comuni o costanti che possono essere utilizzate da tutti gli oggetti. Se la variabile statica non è privata, possiamo accedervi con NomeClasse.nomeVariabile
```
    //Esempio di variabile statica
    private static int conteggio;
    public static String str;
    public static final String DB_USER = "miouser";
```
Metodo statico Java

Come le variabili statiche, i metodi statici appartengono alla classe e non alle istanze della classe. Un metodo statico può accedere solo alle variabili statiche della classe e invocare solo metodi statici della classe. Di solito, i metodi statici sono metodi di utilità che vogliamo esporre per essere utilizzati da altre classi senza la necessità di creare un’istanza. Ad esempio, la classe Collections. Le classi wrapper Java e le classi di utilità contengono molti metodi statici. Il metodo main() che è il punto di ingresso di un programma Java stesso è un metodo statico.
```
    //esempio di metodo statico
    public static void setCount(int count) {
        if(count > 0)
        StaticExample.count = count;
    }
    
    //metodo util statico
    public static int addInts(int i, int...js){
        int sum=i;
        for(int x : js) sum+=x;
        return sum;
    }
```
Dal Java 8 in poi, possiamo avere anche metodi statici nelle interfacce. Per maggiori dettagli si prega di leggere Modifiche all’interfaccia Java 8.
Blocco statico di Java

Il blocco statico di Java è il gruppo di istruzioni che viene eseguito quando la classe viene caricata in memoria dal Java ClassLoader. Il blocco statico viene utilizzato per inizializzare le variabili statiche della classe. Principalmente viene utilizzato per creare risorse statiche quando la classe viene caricata. Non possiamo accedere alle variabili non statiche nel blocco statico. Possiamo avere più blocchi statici in una classe, anche se non ha molto senso. Il codice del blocco statico viene eseguito solo una volta quando la classe viene caricata in memoria.
```
    static{
        //può essere utilizzato per inizializzare risorse quando la classe viene caricata
        System.out.println("Blocco statico di StaticExample");
        //può accedere solo a variabili e metodi statici
        str="Test";
        setCount(2);
    }
```
Classe statica Java

Possiamo utilizzare la parola chiave statica con classi annidate. La parola chiave statica non può essere utilizzata con classi di primo livello. Una classe annidata statica è uguale a qualsiasi altra classe di primo livello ed è annidata solo per comodità di impacchettamento. Leggi: Classi annidate Java

Vediamo tutti gli utilizzi della parola chiave “static” in Java in un programma di esempio. StaticExample.java

package com.journaldev.misc;

public class StaticExample {

    //blocco statico
    static{
        //può essere utilizzato per inizializzare risorse quando la classe viene caricata
        System.out.println("StaticExample static block");
        //può accedere solo a variabili e metodi statici
        str="Test";
        setCount(2);
    }
    
    //più blocchi statici nella stessa classe
    static{
        System.out.println("StaticExample static block2");
    }
    
    //esempio di variabile statica
    private static int count; //kept private to control its value through setter
    public static String str;
    
    public int getCount() {
        return count;
    }

    //esempio di metodo statico
    public static void setCount(int count) {
        if(count > 0)
        StaticExample.count = count;
    }
    
    //metodo util statico
    public static int addInts(int i, int...js){
        int sum=i;
        for(int x : js) sum+=x;
        return sum;
    }

    //esempio di classe statica - utilizzata solo per comodità di raggruppamento
    public static class MyStaticClass{
        public int count;
        
    }

}

Vediamo come utilizzare variabili, metodi e classi statiche in un programma di test. TestStatic.java

package com.journaldev.misc;

public class TestStatic {

    public static void main(String[] args) {
        StaticExample.setCount(5);
        
        //variabili statiche non private possono essere accessibili con il nome della classe
        StaticExample.str = "abc";
        StaticExample se = new StaticExample();
        System.out.println(se.getCount());
        //le variabili statiche di classe e di istanza sono uguali
        System.out.println(StaticExample.str +" is same as "+se.str);
        System.out.println(StaticExample.str == se.str);
        
        //le classi nidificate statiche sono come le normali classi di primo livello
        StaticExample.MyStaticClass myStaticClass = new StaticExample.MyStaticClass();
        myStaticClass.count=10;
        
        StaticExample.MyStaticClass myStaticClass1 = new StaticExample.MyStaticClass();
        myStaticClass1.count=20;
        
        System.out.println(myStaticClass.count);
        System.out.println(myStaticClass1.count);
    }
    
}

L’output del programma di esempio sopra con la parola chiave “static” in Java è:

StaticExample static block
StaticExample static block2
5
abc is same as abc
true
10
20

Si noti che il codice del blocco statico viene eseguito per primo e solo una volta appena la classe viene caricata in memoria. Gli altri output sono autoesplicativi.

Import statico in Java

Normalmente accediamo ai membri statici usando il riferimento alla classe, a partire da Java 1.5 possiamo utilizzare l’importazione statica di Java per evitare il riferimento alla classe. Di seguito è riportato un semplice esempio di importazione statica di Java.

package com.journaldev.test;

public class A {

	public static int MAX = 1000;
	
	public static void foo(){
		System.out.println("foo static method");
	}
}

package com.journaldev.test;

import static com.journaldev.test.A.MAX;
import static com.journaldev.test.A.foo;

public class B {

	public static void main(String args[]){
		System.out.println(MAX); //normally A.MAX
		foo(); // normally A.foo()
	}
}

Nota le dichiarazioni di importazione, per l’importazione statica dobbiamo utilizzare import static seguito dal membro statico completamente classificato di una classe. Per importare tutti i membri statici di una classe, possiamo usare * come in import static com.journaldev.test.A.*;. Dovremmo usarlo solo quando utilizziamo la variabile statica di una classe più volte, non è buono per la leggibilità. Aggiornamento: Ho recentemente creato un video per spiegare la parola chiave statica in Java, dovresti guardarlo qui sotto. https://www.youtube.com/watch?v=2e-l1vb\_fwM

Source:
https://www.digitalocean.com/community/tutorials/static-keyword-in-java

La parola chiave statica in Java

Variabile statica Java

Metodo statico Java

Blocco statico di Java

Classe statica Java

Import statico in Java