Co w języku laickim oznacza "statyczny" w języku Java? [duplikat]

W bardzo laickich terminach klasa jest formą, a obiekt jest kopią wykonaną tą formą. Statyczne należą do formy i mogą być dostępne bezpośrednio bez wykonywania jakichkolwiek kopii, stąd przykład powyżej

Słowo kluczowe statyczne może być używane na kilka różnych sposobów w Javie i prawie we wszystkich przypadkach jest modyfikatorem, co oznacza, że modyfikowana rzecz jest użyteczna bez zamykającej się instancji obiektu.

Java jest językiem zorientowanym obiektowo i domyślnie większość kodu, który piszesz, wymaga użycia instancji obiektu.

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

Aby użyć someField, someMethod, or SomeInnerClass muszę najpierw utworzyć instancję 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();
    }
}

Jeśli deklaruję te rzeczy statyczne, to nie wymagają instancji zamykającej .

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();
    }
}

Deklarowanie czegoś statycznego ma kilka implikacji.

Po pierwsze, może istnieć tylko jedna wartość pola statycznego w całej aplikacji.

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
    }
}

Drugi problem polega na tym, że statyczne metody i klasy wewnętrzne nie mogą uzyskać dostępu do pól w otaczającym obiekcie (ponieważ nie ma jeden).

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
        }

    }
}

Słowo kluczowe statyczne może być również stosowane do wewnętrznych interfejsów, adnotacji i enum.

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

We wszystkich tych przypadkach słowo kluczowe jest zbędne i nie ma żadnego wpływu. Interfejsy, adnotacje i liczby są domyślnie statyczne, ponieważ nigdy nie mają związku z klasą wewnętrzną.

To tylko opisuje, co robią słowa kluczowe. Nie opisuje, czy użycie słowa kluczowego jest złym pomysłem, czy nie. Które mogą być omówione bardziej szczegółowo w innych pytaniach na przykład czy używanie wielu metod statycznych jest złe?

Istnieje również kilka mniej powszechnych zastosowań słowa kluczowego static. Istnieją importy statyczne, które pozwalają na użycie typów statycznych (w tym interfejsów, adnotacji i enum, które nie są redundantnie oznaczone statycznie) bez zastrzeżeń.

//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
    }
}

Wreszcie, istnieją statyczne inicjalizatory, które są blokami kodu, które są uruchamiane podczas pierwszego załadowania klasy(co jest zwykle tuż przed utworzeniem instancji klasy dla pierwszego czas w aplikacji) i (podobnie jak statyczne metody) nie mogą uzyskać dostępu do niestatycznych pól lub metod.

public class SomeObject {

    private static int x;

    static {
        x = 7;
    }
}

Kolejny świetny przykład, kiedy atrybuty statyczne i operacje są używane, gdy chcesz zastosować wzorzec projektowy Singleton . W skrócie, Singleton design pattern zapewnia, że jeden i tylko jeden obiekt danej klasy jest kiedykolwiek zbudowany w ciągu życia systemu. aby zapewnić, że tylko jeden obiekt jest kiedykolwiek zbudowany, typowe implementacje wzorca Singleton zachowują wewnętrzne statyczne odniesienie do pojedynczej dozwolonej instancji obiektu i dostęp do ta instancja jest kontrolowana za pomocą operacji static

Oprócz tego, co zauważył @inkedmn, statyczny członek jest na poziomie klasy. Dlatego wspomniany element jest ładowany do pamięci przez JVM raz dla tej klasy (gdy klasa jest ładowana). Oznacza to, że nie ma N instancji statycznego członka załadowanego dla N instancji klasy, do której należy.

Powyższe punkty są poprawne i chcę dodać kilka ważniejszych punktów na temat statycznego słowa kluczowego.

Wewnętrznie co się dzieje, gdy używasz statycznego słowa kluczowego, to będzie ono przechowywane w pamięci stałej (to jest w pamięci sterty),wiemy, że istnieją dwa rodzaje pamięci są to Pamięci stosu (Pamięć tymczasowa) i Pamięci stosu(Pamięć trwała),więc jeśli nie używasz statycznego słowa kluczowego, to będzie przechowywać w pamięci tymczasowej, która jest w Pamięci stosu pamięć (lub można ją nazwać volatile memory ).

Więc będziesz miał wątpliwości, jaki jest pożytek z tego prawa???

Przykład : static int a=10; (1 program)

Właśnie powiedziałem, że jeśli używasz statycznego słowa kluczowego dla zmiennychlub dla metodyto będzie on przechowywany w pamięci stałej prawo.

Więc zadeklarowałem tę samą zmienną ze słowem kluczowym static w innym programie o innej wartości.

Przykład : static int a = 20; (2 program)

Zmienna 'a' jest przechowywana w pamięci sterty przez program 1 .ta sama statyczna zmienna " a "znajduje się w program 2 w tym czasie nie utworzy ponownie zmiennej" a " w pamięci sterty zamiast tego po prostu zastąpi wartość a z 10 na 20.

Ogólnie rzecz biorąc, stworzy Ponownie zmienną 'a' w pamięci stosu(pamięci tymczasowej), jeśli nie zadeklarujesz 'a' jako zmiennej statycznej.

Ogólnie mogę powiedzieć, że jeśli użyjemy statycznych słowo kluczowe
  1.możemy zapisać pamięć
  2.możemy uniknąć duplikatów
  3.No potrzeba wytworzenia obiektu w kolejności dostępu do zmiennej statycznej przy pomocy nazwy klasy można uzyskać do niej dostęp.