Was macht das Schlüsselwort 'static' in einer Klasse?

Um genau zu sein, habe ich diesen Code ausprobiert:

package hello;

public class Hello {

    Clock clock = new Clock();

    public static void main(String args[]) {
        clock.sayTime();
    }
}

Aber es gab den Fehler

Kein Zugriff auf nicht statisches Feld in der statischen Methode main

Also habe ich die Erklärung dahingehend geändert clock:

static Clock clock = new Clock();

Und es hat funktioniert. Was bedeutet es, dieses Schlüsselwort vor die Deklaration zu setzen? Was genau wird es tun und / oder einschränken, was mit diesem Objekt getan werden kann?

static Mitglieder gehören der Klasse anstelle einer bestimmten Instanz an.

Dies bedeutet, dass nur eine Instanz eines staticFelds vorhanden ist ^[1], selbst wenn Sie eine Million Instanzen der Klasse erstellen oder keine. Es wird von allen Instanzen geteilt.

Da staticMethoden auch nicht zu einer bestimmten Instanz gehören, können sie nicht auf Instanzmitglieder verweisen. Weiß im angegebenen Beispiel mainnicht, auf welche Instanz der HelloKlasse (und damit auf welche Instanz der ClockKlasse) sie sich beziehen soll. staticMitglieder können sich nur auf staticMitglieder beziehen . Instanzmitglieder können natürlich auf staticMitglieder zugreifen .

Randnotiz: Natürlich statickönnen Mitglieder über eine Objektreferenz auf Instanzmitglieder zugreifen .

Beispiel:

public class Example {
    private static boolean staticField;
    private boolean instanceField;
    public static void main(String[] args) {
        // a static method can access static fields
        staticField = true;

        // a static method can access instance fields through an object reference
        Example instance = new Example();
        instance.instanceField = true;
    }

[1]: Abhängig von den Laufzeitmerkmalen kann es eine pro ClassLoader oder AppDomain oder Thread sein, aber das ist nebensächlich.

Dies bedeutet, dass es in Hello nur eine Instanz von "clock" gibt, nicht eine für jede einzelne Instanz der "Hello" -Klasse, oder mehr, dass es unter allen Instanzen von eine gemeinsame "clock" -Referenz gibt die "Hallo" Klasse.

Wenn Sie also irgendwo in Ihrem Code ein "neues Hallo" machen würden: A- Im ersten Szenario (vor der Änderung, ohne "statisch" zu verwenden) würde jedes Mal, wenn ein "neues Hallo" aufgerufen wird, eine neue Uhr erstellt. Aber B- im zweiten Szenario (nach der Änderung mit "statisch") würde jede "neue Hallo" -Instanz weiterhin die ursprüngliche und dieselbe "Uhr" -Referenz gemeinsam nutzen und verwenden, die zuerst erstellt wurde.

Wenn Sie nicht irgendwo außerhalb der Hauptleitung eine "Uhr" benötigen, funktioniert dies genauso gut:

package hello;
public class Hello
{
    public static void main(String args[])
    {
      Clock clock=new Clock();
      clock.sayTime();    
    }
}

Das staticSchlüsselwort bedeutet, dass etwas (ein Feld, eine Methode oder eine verschachtelte Klasse) eher mit dem Typ als mit einer bestimmten Instanz des Typs zusammenhängt. So ruft man beispielsweise Math.sin(...)ohne Instanz der MathKlasse auf, und tatsächlich kann man keine Instanz der MathKlasse erstellen .

Weitere Informationen finden Sie im entsprechenden Teil des Java-Tutorials von Oracle .

Randnotiz

Mit Java können Sie leider auf statische Mitglieder zugreifen, als wären sie Instanzmitglieder, z

// Bad code!
Thread.currentThread().sleep(5000);
someOtherThread.sleep(5000);

Das sieht so aus, als wäre sleepes eine Instanzmethode, aber es ist tatsächlich eine statische Methode - der aktuelle Thread wird immer in den Ruhezustand versetzt. Es ist besser, dies im aufrufenden Code klar zu machen:

// Clearer
Thread.sleep(5000);

Das staticSchlüsselwort in Java bedeutet, dass die Variable oder Funktion von allen Instanzen dieser Klasse gemeinsam genutzt wird, da sie zum Typ gehört , nicht von den tatsächlichen Objekten selbst.

Wenn Sie also eine Variable haben: private static int i = 0;und sie i++in einer Instanz inkrementieren ( ), wird die Änderung in allen Instanzen wiedergegeben.iwird jetzt in allen Fällen 1 sein.

Statische Methoden können verwendet werden, ohne ein Objekt zu instanziieren.

Grundlegende Verwendung statischer Elemente ...

public class Hello
{
    // value / method
    public static String staticValue;
    public String nonStaticValue;
}

class A
{
    Hello hello = new Hello();
    hello.staticValue = "abc";
    hello.nonStaticValue = "xyz";
}

class B
{
    Hello hello2 = new Hello(); // here staticValue = "abc"
    hello2.staticValue; // will have value of "abc"
    hello2.nonStaticValue; // will have value of null
}

Auf diese Weise können Sie Werte für alle Klassenmitglieder freigeben, ohne die Klasseninstanz Hello an eine andere Klasse zu senden. Und mit statischer Aufladung müssen Sie keine Klasseninstanz erstellen.

Hello hello = new Hello();
hello.staticValue = "abc";

Sie können statische Werte oder Methoden einfach nach Klassennamen aufrufen:

Hello.staticValue = "abc";

Statisch bedeutet, dass Sie keine Instanz der Klasse erstellen müssen, um die der Klasse zugeordneten Methoden oder Variablen zu verwenden. In Ihrem Beispiel könnten Sie anrufen:

Hello.main(new String[]()) //main(...) is declared as a static function in the Hello class

direkt statt:

Hello h = new Hello();
h.main(new String[]()); //main(...) is a non-static function linked with the "h" variable

Innerhalb einer statischen Methode (die zu einer Klasse gehört) können Sie nicht auf Mitglieder zugreifen, die nicht statisch sind, da ihre Werte von Ihrer Instanziierung der Klasse abhängen. Ein nicht statisches Clock-Objekt, das ein Instanzmitglied ist, hat für jede Instanz Ihrer Hello-Klasse einen anderen Wert / eine andere Referenz. Daher können Sie nicht über den statischen Teil der Klasse darauf zugreifen.

Statisch in Java:

Static ist ein Modifikator ohne Zugriff. Das statische Schlüsselwort gehört zur Klasse als Instanz der Klasse. kann verwendet werden, um eine Variable oder Methode an eine Klasse anzuhängen.

Das statische Schlüsselwort kann verwendet werden mit:

Methode

Variable

Klasse in einer anderen Klasse verschachtelt

Initialisierungsblock

Kann nicht verwendet werden mit:

Klasse (nicht verschachtelt)

Konstrukteur

Schnittstellen

Methode Lokale innere Klasse (Differenz dann verschachtelte Klasse)

Methoden der inneren Klasse

Instanzvariablen

Lokale Variablen

Beispiel:

Stellen Sie sich das folgende Beispiel mit einer Instanzvariablen namens count vor, die im Konstruktor inkrementiert wurde:

package pkg;

class StaticExample {
    int count = 0;// will get memory when instance is created

    StaticExample() {
        count++;
        System.out.println(count);
    }

    public static void main(String args[]) {

        StaticExample c1 = new StaticExample();
        StaticExample c2 = new StaticExample();
        StaticExample c3 = new StaticExample();

    }
}

Ausgabe:

1 1 1

Da die Instanzvariable zum Zeitpunkt der Objekterstellung den Speicher erhält, verfügt jedes Objekt über die Kopie der Instanzvariablen. Wenn sie inkrementiert wird, wird sie nicht auf andere Objekte übertragen.

Wenn wir nun die Anzahl der Instanzvariablen in eine statische ändern, erzeugt das Programm eine andere Ausgabe:

package pkg;

class StaticExample {
    static int count = 0;// will get memory when instance is created

    StaticExample() {
        count++;
        System.out.println(count);
    }

    public static void main(String args[]) {

        StaticExample c1 = new StaticExample();
        StaticExample c2 = new StaticExample();
        StaticExample c3 = new StaticExample();

    }
}

Ausgabe:

1 2 3

In diesem Fall erhält die statische Variable den Speicher nur einmal. Wenn ein Objekt den Wert der statischen Variablen ändert, behält es seinen Wert bei.

Statisch mit Finale:

Die globale Variable, die als endgültig und statisch deklariert ist, bleibt für die gesamte Ausführung unverändert. Denn statische Elemente werden im Klassenspeicher gespeichert und in der gesamten Ausführung nur einmal geladen. Sie sind allen Objekten der Klasse gemeinsam. Wenn Sie statische Variablen als endgültig deklarieren, kann keines der Objekte seinen Wert ändern, da er endgültig ist. Daher werden als endgültig und statisch deklarierte Variablen manchmal als Konstanten bezeichnet. Alle Felder von Schnittstellen werden als Konstanten bezeichnet, da sie standardmäßig endgültig und statisch sind.

Bildressource: Endgültig statisch

Lassen Sie mich mit einem Bild versuchen, um vorhandene Antworten zu ergänzen:

Auf ALLE Sparkonten wird ein Zinssatz von 2% angewendet. Daher ist es statisch .

Ein Gleichgewicht sollte individuell sein , damit es nicht statisch ist.

Diese Diskussion hat bisher Überlegungen zum Klassenladeprogramm ignoriert. Genau genommen werden statische Java-Felder von allen Instanzen einer Klasse für einen bestimmten Klassenladeprogramm gemeinsam genutzt .

Ein Feld kann entweder der Klasse oder einer Instanz einer Klasse zugewiesen werden. Standardmäßig sind Felder Instanzvariablen. Durch die Verwendung staticdes Feldes wird eine Klassenvariable, daher gibt es nur eine clock. Wenn Sie Änderungen an einer Stelle vornehmen, ist diese überall sichtbar. Instanzvariablen werden unabhängig voneinander geändert.

Das Schlüsselwort staticwird verwendet, um ein Feld oder eine Methode als zur Klasse selbst und nicht zur Instanz gehörend zu bezeichnen. Wenn das Objekt unter Verwendung Ihres Codes Clockstatisch ist, Helloteilen alle Instanzen der Klasse dieses ClockDatenelement (Feld) gemeinsam. Wenn Sie es nicht statisch machen, kann jede einzelne Instanz von Helloein eindeutiges ClockFeld haben.

Das Problem ist, dass Sie Ihrer Klasse eine Hauptmethode hinzugefügt haben Hello, damit Sie den Code ausführen können. Das Problem hierbei ist, dass die Hauptmethode statisch ist und sich daher nicht auf nicht statische Felder oder darin enthaltene Methoden beziehen kann. Sie können dies auf zwei Arten lösen:

1. Machen Sie alle Felder und Methoden der HelloKlasse statisch, damit auf sie im Hauptverzeichnis verwiesen werden kann werden kann. Dies ist wirklich keine gute Sache (oder der falsche Grund, ein Feld und / oder eine Methode statisch zu machen)
2. Erstellen Sie eine Instanz Ihrer HelloKlasse in der Hauptmethode und greifen Sie auf alle Felder und Methoden so zu, wie sie ursprünglich vorgesehen waren.

Für Sie bedeutet dies die folgende Änderung Ihres Codes:

package hello;

public class Hello {

    private Clock clock = new Clock();

    public Clock getClock() {
        return clock;
    }

    public static void main(String args[]) {
        Hello hello = new Hello();
        hello.getClock().sayTime();
    }
}

In Java kann das staticSchlüsselwort einfach als Hinweis auf Folgendes angesehen werden:

"ohne Rücksicht oder Beziehung zu einer bestimmten Instanz"

Wenn Sie so denken static, wird es einfacher, seine Verwendung in den verschiedenen Kontexten zu verstehen, in denen es anzutreffen ist:

• Ein staticFeld ist ein Feld, das eher zur Klasse als zu einer bestimmten Instanz gehört

• Eine staticMethode ist eine Methode, von der keine Ahnung hat this; Es ist in der Klasse definiert und kennt keine bestimmte Instanz dieser Klasse, es sei denn, eine Referenz wird an sie übergeben

• Eine staticMitgliedsklasse ist eine verschachtelte Klasse ohne Vorstellung oder Kenntnis einer Instanz ihrer umschließenden Klasse (es sei denn, ihr wird ein Verweis auf eine umschließende Klasseninstanz übergeben).

Static macht das Clock-Mitglied zu einem Klassenmitglied anstelle eines Instanzmitglieds. Ohne das statische Schlüsselwort müssten Sie eine Instanz der Hello-Klasse erstellen (die eine Clock-Member-Variable hat) - z

Hello hello = new Hello();
hello.clock.sayTime();

Statische Methoden verwenden keine Instanzvariablen der Klasse, in der sie definiert sind. Eine sehr gute Erklärung des Unterschieds finden Sie auf dieser Seite

Ich habe eine Vorliebe für statische Methoden (nur wenn möglich) in "Helfer" -Klassen entwickelt.

Die aufrufende Klasse muss keine weitere Mitgliedsvariable (Instanzvariable) der Hilfsklasse erstellen. Sie rufen einfach die Methoden der Hilfsklasse auf. Außerdem wird die Hilfsklasse verbessert, da Sie keinen Konstruktor mehr benötigen und keine Mitgliedsvariablen (Instanzvariablen) benötigen.

Es gibt wahrscheinlich andere Vorteile.

//Here is an example 

public class StaticClass 
{
    static int version;
    public void printVersion() {
         System.out.println(version);
    }
}

public class MainClass 
{
    public static void main(String args[]) {  
        StaticClass staticVar1 = new StaticClass();
        staticVar1.version = 10;
        staticVar1.printVersion() // Output 10

        StaticClass staticVar2 = new StaticClass();
        staticVar2.printVersion() // Output 10
        staticVar2.version = 20;
        staticVar2.printVersion() // Output 20
        staticVar1.printVersion() // Output 20
    }
}

Kann auch an statische Mitglieder denken, die keinen "this" -Zeiger haben. Sie werden von allen Instanzen gemeinsam genutzt.

Statische Konzepte verstehen

public class StaticPractise1 {
    public static void main(String[] args) {
        StaticPractise2 staticPractise2 = new StaticPractise2();
        staticPractise2.printUddhav(); //true
        StaticPractise2.printUddhav(); /* false, because printUddhav() is although inside StaticPractise2, but it is where exactly depends on PC program counter on runtime. */

        StaticPractise2.printUddhavsStatic1(); //true
        staticPractise2.printUddhavsStatic1(); /*false, because, when staticPractise2 is blueprinted, it tracks everything other than static  things and it organizes in its own heap. So, class static methods, object can't reference */

    }
}

Zweite Klasse

public class StaticPractise2 {
    public static void printUddhavsStatic1() {
        System.out.println("Uddhav");
    }

    public void printUddhav() {
        System.out.println("Uddhav");
    }
}

main() ist eine statische Methode, die zwei grundlegende Einschränkungen aufweist:

1. Die statische Methode kann kein nicht statisches Datenelement verwenden oder eine nicht statische Methode direkt aufrufen.

2. this()und super()kann nicht im statischen Kontext verwendet werden.

   class A {  
       int a = 40; //non static
       public static void main(String args[]) {  
           System.out.println(a);  
       }  
   }

Ausgabe: Kompilierungszeitfehler

Auf statische Variablen kann nur mit statischen Methoden zugegriffen werden. Wenn wir also die statischen Variablen deklarieren, sind diese Getter- und Setter-Methoden statische Methoden

Statische Methoden sind eine Klassenebene, auf die wir über den Klassennamen zugreifen können

Das Folgende ist ein Beispiel für statische Variablen Getter und Setter:

public class Static 
{

    private static String owner;
    private static int rent;
    private String car;
    public String getCar() {
        return car;
    }
    public void setCar(String car) {
        this.car = car;
    }
    public static int getRent() {
        return rent;
    }
    public static void setRent(int rent) {
        Static.rent = rent;
    }
    public static String getOwner() {
        return owner;
    }

    public static void setOwner(String owner) {
        Static.owner = owner;
    }

}

Eine Frage wurde gefragt , hier über die Wahl des Wortes ‚statisch‘ für dieses Konzept. Es wurde auf diese Frage getäuscht, aber ich glaube nicht, dass die Etymologie klar angesprochen wurde. Damit...

Dies liegt an der Wiederverwendung von Schlüsselwörtern, beginnend mit C.

Betrachten Sie Datendeklarationen in C (innerhalb eines Funktionskörpers):

    void f() {
        int foo = 1;
        static int bar = 2;
         :
    }

Die Variable foo wird beim Eingeben der Funktion auf dem Stapel erstellt (und beim Beenden der Funktion zerstört). Im Gegensatz dazu ist die Bar immer vorhanden, daher ist sie im Sinne des üblichen Englisch "statisch" - sie führt nirgendwo hin.

Java und ähnliche Sprachen haben dasselbe Konzept für Daten. Daten können entweder pro Instanz der Klasse (pro Objekt) oder einmal für die gesamte Klasse zugewiesen werden. Da Java eine vertraute Syntax für C / C ++ - Programmierer anstrebt, ist hier das Schlüsselwort 'static' angemessen.

    class C {
        int foo = 1;
        static int bar = 2;
         :
    }

Zuletzt kommen wir zu Methoden.

    class C {
        int foo() { ... }
        static int bar() { ... }
         :
    }

Konzeptionell gibt es für jede Instanz der Klasse C eine Instanz von foo (). Es gibt nur eine Instanz von bar () für die gesamte Klasse C. Dies ist parallel zu dem Fall, den wir für Daten besprochen haben, und verwendet daher 'static' 'ist wieder eine vernünftige Wahl, insbesondere wenn Sie Ihrer Sprache keine reservierteren Schlüsselwörter hinzufügen möchten.