In termini semplici, cosa significa "statico" in Java?

Question

Mi è stato detto diverse definizioni per questo, ho guardato su Wikipedia, ma come principiante di Java non sono ancora sicuro di cosa significhi. Qualcuno che parla fluentemente Java e idiota?

Answer 1

statico indica che la variabile o il metodo contrassegnato come tale è disponibile a livello di classe. In altre parole, non è necessario creare un'istanza della classe per accedervi.

public class Foo { 
    public static void doStuff(){ 
     // does stuff 
    } 
} 

Così, invece di creare un'istanza di Foo e quindi chiamando doStuff come questo:

Foo f = new Foo(); 
f.doStuff(); 

Basta chiamare il metodo direttamente contro la classe, in questo modo:

Foo.doStuff(); 

Answer 2

In termini molto laici la classe è uno stampo e l'oggetto è la copia realizzata con quella muffa. Statico appartiene allo stampo e può essere consultato direttamente senza effettuare copie, quindi l'esempio sopra

Answer 3

In aggiunta a ciò che @inkedmn ha sottolineato, un membro statico è a livello di classe. Pertanto, il suddetto membro viene caricato in memoria dalla JVM una volta per quella classe (quando la classe viene caricata). Cioè, non ci sono n istanze di un membro statico caricato per n istanze della classe a cui appartiene.

Answer 4

Un altro grande esempio di quando si utilizzano gli attributi statici e le operazioni quando si desidera applicare il modello di progettazione Singleton . In poche parole, il modello di progettazione di Singleton garantisce che un solo oggetto di una determinata classe venga mai costruito durante la vita del sistema. per garantire che venga creato un solo oggetto, le tipiche implementazioni del modello Singleton mantengono un riferimento statico interno alla singola istanza dell'oggetto consentita e l'accesso a tale istanza viene controllato utilizzando un'operazione static

Answer 5

I punti sopra indicati sono corretti e desidero aggiungere alcuni punti più importanti sulla parola chiave statica.

Internamente ciò che accade quando si utilizza parola chiave statica che memorizza in memoria permanente (cioè nel memoria heap), sappiamo che ci sono due tipi di memoria sono memoria dello stack (memoria temporanea) e memoria heap (memoria permanente), quindi se non si utilizza la parola chiave statica poi memorizzerà nella memoria temporanea che si trova in memoria pila (o si può chiamare come memoria volatile).

quindi avrai un dubbio che a che serve questo ???

esempio: static int a = 10; (1 programma)

solo ora ho detto se si utilizza parola chiave statica per variabili o per metodo memorizzerà in memoria permanente destra.

quindi ho dichiarato la stessa variabile con la parola chiave statica in un altro programma con valore diverso.

esempio: static int a = 20; (2 programma)

la variabile 'a' è memorizzato nella memoria heap programma 1 .la stessa variabile statica 'un' si trova in programma 2 in quel momento lo non creerà ancora una volta una variabile "a" nella memoria heap invece di sostituire solo il valore di a da 10 a 20.

In generale verrà creato ancora una volta variabile 'a' nella memoria di stack (memoria temporanea) se non si dichiarerà 'a' come variabile statica.

Nel complesso posso dire che, se usiamo parola chiave static
  1.We può risparmiare memoria
  2.we può evitare duplicati
  3.No bisogno di creare oggetti in-fine di accedere variabile statica con l'aiuto del nome della classe puoi accedervi.

Answer 6

La parola chiave statica può essere utilizzata in vari modi in Java e in quasi tutti i casi è un modificatore che significa che la cosa che sta modificando è utilizzabile senza un'istanza di oggetto che contiene.

Java è un linguaggio orientato agli oggetti e, per impostazione predefinita, la maggior parte del codice che si scrive richiede un'istanza dell'oggetto da utilizzare.

public class SomeObject { 
    public int someField; 
    public void someMethod() { }; 
    public Class SomeInnerClass { }; 
} 

Per poter utilizzare SomeField, someMethod o SomeInnerClass devo creare prima un'istanza di SomeObject.

public class SomeOtherObject { 
    public void doSomeStuff() { 
     SomeObject anInstance = new SomeObject(); 
     anInstance.someField = 7; 
     anInstance.someMethod(); 
     //Non-static inner classes are usually not created outside of the 
     //class instance so you don't normally see this syntax 
     SomeInnerClass blah = anInstance.new SomeInnerClass(); 
    } 
} 

Se io dichiaro quelle cose statica allora non richiedono un'istanza racchiude.

public class SomeObjectWithStaticStuff { 
    public static int someField; 
    public static void someMethod() { }; 
    public static Class SomeInnerClass { }; 
} 

public class SomeOtherObject { 
    public void doSomeStuff() { 
     SomeObjectWithStaticStuff.someField = 7; 
     SomeObjectWithStaticStuff.someMethod(); 
     SomeObjectWithStaticStuff.SomeInnerClass blah = new SomeObjectWithStaticStuff.SomeInnerClass(); 
     //Or you can also do this if your imports are correct 
     SomeInnerClass blah2 = new SomeInnerClass(); 
    } 
} 

Dichiarare qualcosa di statico ha diverse implicazioni.

Innanzitutto, è possibile sempre un solo valore di un campo statico nell'intera applicazione.

public class SomeOtherObject { 
    public void doSomeStuff() { 
     //Two objects, two different values 
     SomeObject instanceOne = new SomeObject(); 
     SomeObject instanceTwo = new SomeObject(); 
     instanceOne.someField = 7; 
     instanceTwo.someField = 10; 
     //Static object, only ever one value 
     SomeObjectWithStaticStuff.someField = 7; 
     SomeObjectWithStaticStuff.someField = 10; //Redefines the above set 
    } 
} 

Il secondo problema è che metodi statici e classi interne non possono accedere campi nell'oggetto racchiude (poiché non esiste).

public class SomeObjectWithStaticStuff { 
    private int nonStaticField; 
    private void nonStaticMethod() { }; 

    public static void someStaticMethod() { 
     nonStaticField = 7; //Not allowed 
     this.nonStaticField = 7; //Not allowed, can never use *this* in static 
     nonStaticMethod(); //Not allowed 
     super.someSuperMethod(); //Not allowed, can never use *super* in static 
    } 

    public static class SomeStaticInnerClass { 

     public void doStuff() { 
      someStaticField = 7; //Not allowed 
      nonStaticMethod(); //Not allowed 
      someStaticMethod(); //This is ok 
     } 

    } 
} 

La parola chiave statica può anche essere applicata a interfacce interne, annotazioni ed enumerazioni.

public class SomeObject { public static interface SomeInterface {}; public static @interface SomeAnnotation {}; public static enum SomeEnum {}; }

In tutti questi casi la parola chiave è ridondante e non ha alcun effetto. Interfacce, annotazioni ed enumerazioni sono statiche di default perché non hanno mai una relazione con una classe interna.

Questo descrive solo ciò che fa la parola chiave. Non descrive se l'uso della parola chiave sia una cattiva idea o meno. Questo può essere trattato più dettagliatamente in altre domande come Is using a lot of static methods a bad thing?

Ci sono anche alcuni usi meno comuni della parola chiave statica. Esistono importazioni statiche che consentono di utilizzare i tipi statici (comprese le interfacce, le annotazioni e le enumerazioni non contrassegnate in modo ridondante statico) non qualificate.

//SomeStaticThing.java 
public class SomeStaticThing { 
    public static int StaticCounterOne = 0; 
} 

//SomeOtherStaticThing.java 
public class SomeOtherStaticThing { 
    public static int StaticCounterTwo = 0; 
} 

//SomeOtherClass.java 
import static some.package.SomeStaticThing.*; 
import some.package.SomeOtherStaticThing.*; 

public class SomeOtherClass { 
    public void doStuff() { 
     StaticCounterOne++; //Ok 
     StaticCounterTwo++; //Not ok 
     SomeOtherStaticThing.StaticCounterTwo++; //Ok 
    } 
} 

Infine, ci sono inizializzatori statici che sono blocchi di codice che vengono eseguiti quando la classe viene caricata prima (che è solito appena prima di una classe viene istanziata per la prima volta in un'applicazione) e (come metodi statici) non possono accedere a campi o metodi non statici.

public class SomeObject { 

    private static int x; 

    static { 
     x = 7; 
    } 
} 

Mi scuso se questo va più in dettaglio del necessario, mi è stato chiesto di spostare questa risposta qui da un'altra domanda cui dettaglio è stato un po 'più appropriato.