In parole povere, cosa significa “statico” in Java?

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?

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

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

Quindi, invece di creare un’istanza di Foo e quindi chiamare doStuff questo modo:

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

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

 Foo.doStuff(); 

In termini molto laici la class è uno stampo e l’object è la copia realizzata con quella muffa. Statico appartiene allo stampo e può essere consultato direttamente senza fare alcuna copia, da qui l’esempio sopra

La parola chiave static può essere utilizzata in molti modi diversi in Java e in quasi tutti i casi è un modificatore che significa che la cosa che sta modificando è utilizzabile senza un’istanza di object che lo racchiude .

Java è un linguaggio orientato agli oggetti e per impostazione predefinita gran parte del codice che scrivi richiede un’istanza dell’object da utilizzare.

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

Per utilizzare alcuni campi, alcuni metodi o SomeInnerClass devo prima creare un’istanza di SomeObject .

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

Se dichiaro quelle cose statiche, esse non richiedono un’istanza che le 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, è ansible 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 i metodi statici e le classi interne non possono accedere ai campi nell’object che lo racchiude (poiché non ce n’è uno).

 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 class interna.

Questo descrive solo cosa fa la parola chiave. Non descrive se l’uso della parola chiave sia una ctriggers idea o meno. Questo può essere trattato in modo più dettagliato in altre domande, ad esempio l’ utilizzo di molti metodi statici come una cosa negativa?

Ci sono anche alcuni usi meno comuni della parola chiave static. 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, esistono inizializzatori statici che sono blocchi di codice che vengono eseguiti quando la class viene caricata per la prima volta (che di solito è appena prima che una class venga istanziata per la prima volta in un’applicazione) e (come i metodi statici) non possono accedere ai campi non statici o metodi.

 public class SomeObject { private static int x; static { x = 7; } } 

Mi scuso se questo va più nel dettaglio del necessario, mi è stato chiesto di spostare questa risposta qui da un’altra domanda dove il dettaglio era un po ‘più appropriato.

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

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

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

Internamente ciò che accade quando si utilizza la parola chiave statica è che verrà memorizzato nella memoria permanente (cioè nella memoria heap ), sappiamo che ci sono due tipi di memoria che sono memoria di stack (memoria temporanea) e memoria heap (memoria permanente), quindi se non si utilizza la parola chiave statica, la memoria temporanea verrà archiviata nella memoria di stack (oppure è ansible chiamarla memoria volatile ).

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

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

solo ora ho detto se si usa la parola chiave statica per variabili o per il metodo che verrà memorizzato nella memoria permanente a destra.

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

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

la variabile ‘a’ è memorizzata nella memoria heap dal programma 1. la stessa variabile statica ‘a’ si trova nel programma 2 in quel momento non creerà ancora una variabile ‘a’ nella memoria heap invece che sostituirà solo il valore di un da 10 a 20 .

In generale creerà ancora una variabile ‘a’ nella memoria dello stack (memoria temporanea) se non dichiarerai ‘a’ come variabile statica.

nel complesso posso dire che, se usiamo la parola chiave statica
1. possiamo risparmiare memoria
2. possiamo evitare duplicati
3. Non c’è bisogno di creare oggetti per accedere alla variabile statica con l’aiuto del nome della class, è ansible accedervi.