prywatny końcowy atrybut statyczny a prywatny końcowy atrybut

W Javie jaka jest różnica między:

private final static int NUMBER = 10;

i

private final int NUMBER = 10;

Oba są privatei final, różnica jest staticatrybutem.

Co lepsze? I dlaczego?

Ogólnie staticoznacza „związany z samym typem , a nie z instancją typu”.

Oznacza to, że możesz odwoływać się do zmiennej statycznej bez tworzenia instancji tego typu, a każdy kod odnoszący się do zmiennej odnosi się do dokładnie tych samych danych. Porównaj to ze zmienną instancji: w takim przypadku istnieje jedna niezależna wersja zmiennej na instancję klasy. Na przykład:

Test x = new Test();
Test y = new Test();
x.instanceVariable = 10;
y.instanceVariable = 20;
System.out.println(x.instanceVariable);

drukuje 10: y.instanceVariablei x.instanceVariablesą oddzielne, bo xi yodnoszą się do różnych obiektów.

Państwo może odnosić się do elementów statycznych poprzez referencje, chociaż jest to zły pomysł, aby to zrobić. Gdybyśmy:

Test x = new Test();
Test y = new Test();
x.staticVariable = 10;
y.staticVariable = 20;
System.out.println(x.staticVariable);

to by wydrukowało 20 - jest tylko jedna zmienna, a nie jedna na instancję. Łatwiej byłoby napisać to jako:

Test x = new Test();
Test y = new Test();
Test.staticVariable = 10;
Test.staticVariable = 20;
System.out.println(Test.staticVariable);

To czyni zachowanie o wiele bardziej oczywistym. Nowoczesne IDE zwykle sugerują zmianę drugiego wpisu na trzeci.

Nie ma powodu, aby deklaracja inline inicjalizowała wartość w następujący sposób, ponieważ każda instancja będzie miała własną, NUMBERale zawsze o tej samej wartości (jest niezmienna i inicjowana literałem). Jest to to samo, co dla jednej final staticinstancji tylko jedna zmienna.

private final int NUMBER = 10;

Dlatego jeśli nie można go zmienić, nie ma sensu mieć jednej kopii na instancję.

Ale ma sens, jeśli jest inicjowany w takim konstruktorze:

// No initialization when is declared
private final int number;

public MyClass(int n) {
   // The variable can be assigned in the constructor, but then
   // not modified later.
   number = n;
}

Teraz dla każdego wystąpienia MyClassmożemy mieć inną, ale niezmienną wartość number.

Na końcowy może być przypisane różne wartości w czasie pracy, kiedy inicjowany. Na przykład

Class Test{
  public final int a;
}

Test t1  = new Test();
t1.a = 10;
Test t2  = new Test();
t2.a = 20; //fixed

Zatem każde wystąpienie ma inną wartość pola a .

W przypadku statycznego finału wszystkie instancje mają tę samą wartość i nie można ich zmienić po pierwszej inicjalizacji.

Class TestStatic{
      public static final int a;
}

TestStatic t1  = new TestStatic();
t1.a = 10;
TestStatic t2  = new TestStatic();
t1.a = 20;   // ERROR, CAN'T BE ALTERED AFTER THE FIRST INITIALIZATION.

A staticpobyty zmienne w pamięci przez cały okres stosowania i jest inicjowany podczas klasowej załadunku. Za statickażdym razem, gdy newbudujesz obiekt, inicjowana jest zmienna . Ogólnie lepiej jest użyć:

private static final int NUMBER = 10;

Dlaczego? Zmniejsza to zużycie pamięci na instancję. Prawdopodobnie jest to również korzystne dla trafień w pamięci podręcznej. Ma to po prostu sens: staticpowinno się go używać do rzeczy, które są współużytkowane we wszystkich instancjach (zwanych też obiektami) określonego typu (zwanych też class).

statyczny oznacza „związany z klasą”; bez niego zmienna jest powiązana z każdą instancją klasy. Jeśli jest statyczny, oznacza to, że będziesz mieć tylko jeden w pamięci; jeśli nie, będziesz mieć jeden dla każdego utworzonego wystąpienia. statyczny oznacza, że ​​zmienna pozostanie w pamięci tak długo, jak klasa zostanie załadowana; bez niego zmienna może zostać wygenerowana gc, gdy jest to jej instancja.

Czytając odpowiedzi, nie znalazłem żadnego prawdziwego testu, który miałby sens. Oto moje 2 centy:

public class ConstTest
{

    private final int         value             = 10;
    private static final int  valueStatic       = 20;
    private final File        valueObject       = new File("");
    private static final File valueObjectStatic = new File("");

    public void printAddresses() {


        System.out.println("final int address " +
                ObjectUtils.identityToString(value));
        System.out.println("final static int address " +
                ObjectUtils.identityToString(valueStatic));
        System.out.println("final file address " + 
                ObjectUtils.identityToString(valueObject));
        System.out.println("final static file address " + 
                ObjectUtils.identityToString(valueObjectStatic));
    }


    public static void main(final String args[]) {


        final ConstTest firstObj = new ConstTest();
        final ConstTest sndObj = new ConstTest();

        firstObj.printAdresses();
        sndObj.printAdresses();
    }

}

Wyniki dla pierwszego obiektu:

final int address java.lang.Integer@6d9efb05
final static int address java.lang.Integer@60723d7c
final file address java.io.File@6c22c95b
final static file address java.io.File@5fd1acd3

Wyniki dla drugiego obiektu:

final int address java.lang.Integer@6d9efb05
final static int address java.lang.Integer@60723d7c
final file address java.io.File@3ea981ca
final static file address java.io.File@5fd1acd3

Wniosek:

Tak jak myślałem, Java robi różnicę między prymitywnymi a innymi typami. Typy pierwotne w Javie są zawsze „buforowane”, tak samo dla literałów ciągów (nie nowych obiektów String), więc nie ma różnicy między elementami statycznymi i niestatycznymi.

Istnieje jednak duplikacja pamięci dla elementów niestatycznych, jeśli nie są one instancją typu pierwotnego.

Zmiana wartości valueStatic na 10 pójdzie nawet dalej, ponieważ Java da te same adresy dwóm zmiennym int.

Podczas gdy inne odpowiedzi wydają się jasno wyjaśniać, że generalnie nie ma powodu, aby używać stałych niestatycznych, nie mogłem znaleźć nikogo wskazującego, że możliwe są różne instancje o różnych wartościach dla ich zmiennych stałych.

Rozważ następujący przykład:

public class TestClass {
    private final static double NUMBER = Math.random();

    public TestClass () {
        System.out.println(NUMBER);
    }
}

Utworzenie trzech instancji TestClass spowoduje wydrukowanie tej samej losowej wartości trzy razy, ponieważ tylko jedna wartość jest generowana i zapisywana w stałej statycznej.

Jednak zamiast tego spróbuj wykonać następujący przykład:

public class TestClass {
    private final double NUMBER = Math.random();

    public TestClass () {
        System.out.println(NUMBER);
    }
}

Utworzenie trzech instancji TestClass spowoduje teraz wydrukowanie trzech różnych losowych wartości, ponieważ każda instancja ma swoją własną, losowo generowaną stałą wartość.

Nie mogę wymyślić żadnej sytuacji, w której przydałoby się mieć różne stałe wartości w różnych przypadkach, ale mam nadzieję, że to pomaga wskazać, że istnieje wyraźna różnica między finałami statycznymi i niestatycznymi.

Jak już powiedział Jon, zmienna statyczna, zwana także zmienną klasową, jest zmienną, która istnieje między instancjami klasy.

Tutaj znalazłem przykład :

public class StaticVariable
{
  static int noOfInstances;
  StaticVariable()
  {
    noOfInstances++;
  }
  public static void main(String[] args)
  {
    StaticVariable sv1 = new StaticVariable();
    System.out.println("No. of instances for sv1 : " + sv1.noOfInstances);

    StaticVariable sv2 = new StaticVariable();
    System.out.println("No. of instances for sv1 : "  + sv1.noOfInstances);
    System.out.println("No. of instances for st2 : "  + sv2.noOfInstances);

    StaticVariable sv3 = new StaticVariable();
    System.out.println("No. of instances for sv1 : "  + sv1.noOfInstances);
    System.out.println("No. of instances for sv2 : "  + sv2.noOfInstances);
    System.out.println("No. of instances for sv3 : "  + sv3.noOfInstances);
  }
}

Dane wyjściowe programu podano poniżej:

Jak widać w tym przykładzie, każdy obiekt ma własną kopię zmiennej klasy.

C:\java>java StaticVariable
No. of instances for sv1 : 1
No. of instances for sv1 : 2
No. of instances for st2 : 2
No. of instances for sv1 : 3
No. of instances for sv2 : 3
No. of instances for sv3 : 3

Z przeprowadzonych przeze mnie testów statyczne zmienne końcowe nie są takie same jak zmienne końcowe (niestatyczne)! Ostateczne (niestatyczne) zmienne mogą różnić się w zależności od obiektu !!! Ale to tylko wtedy, gdy inicjalizacja zostanie wykonana w konstruktorze! (Jeśli nie zostanie zainicjowany z konstruktora, to tylko marnotrawstwo pamięci, ponieważ tworzy końcowe zmienne dla każdego tworzonego obiektu, którego nie można zmienić).

Na przykład:

class A
{
    final int f;
    static final int sf = 5;

    A(int num)
    {
        this.f = num;
    }

    void show()
    {
        System.out.printf("About Object: %s\n Final: %d\n Static Final: %d\n\n", this.toString(), this.f, sf);
    }

    public static void main(String[] args)
    {
        A ob1 = new A(14);
        ob1.show();

        A ob2 = new A(21);
        ob2.show();

    }
}

Na ekranie pojawia się:

O obiekcie: A @ addbf1 Finał: 14 Statyczny finał: 5

O obiekcie: A @ 530daa Finał: 21 Statyczny finał: 5

Anonimowy student informatyki pierwszego roku, Grecja

Co więcej, odpowiedź Jona, jeśli użyjesz statycznego finału, będzie zachowywał się jak swego rodzaju „definicja”. Po skompilowaniu klasy, która z niej korzysta, będzie ona spalona w skompilowanym pliku .class. Sprawdź mój wątek na ten temat tutaj .

Dla twojego głównego celu: Jeśli nie użyjesz NUMERU inaczej w różnych instancjach klasy, radzę użyć ostatecznego i statycznego. (Trzeba tylko pamiętać, aby nie kopiować skompilowanych plików klas, nie biorąc pod uwagę możliwych problemów, takich jak ten opisany w moim studium przypadku. Większość przypadków nie występuje, nie martw się :))

Aby pokazać, jak używać różnych wartości w instancjach, sprawdź ten kod:

public class JustFinalAttr {
  public final int Number;

  public JustFinalAttr(int a){
    Number=a;
  }
}

...System.out.println(new JustFinalAttr(4).Number);

Oto moje dwa centy:

final           String CENT_1 = new Random().nextInt(2) == 0 ? "HEADS" : "TAILS";
final   static  String CENT_2 = new Random().nextInt(2) == 0 ? "HEADS" : "TAILS";

Przykład:

package test;

public class Test {

    final long OBJECT_ID = new Random().nextLong();
    final static long CLASSS_ID = new Random().nextLong();

    public static void main(String[] args) {
        Test[] test = new Test[5];
        for (int i = 0; i < test.length; i++){
            test[i] = new Test();
            System.out.println("Class id: "+test[i].CLASSS_ID);//<- Always the same value
            System.out.println("Object id: "+test[i].OBJECT_ID);//<- Always different
        }
    }
}

Kluczem jest to, że zmienne i funkcje mogą zwracać różne wartości, dlatego do zmiennych końcowych można przypisywać różne wartości.

Kolejny prosty przykład, aby zrozumieć użycie statycznych, statycznych zmiennych końcowych, końcowych. Komentarze do kodu mają odpowiednie wyjaśnienie.

public class City {

    // base price that is always same for all objects[For all cities].
    private static double iphone_base_price = 10000;

    // this is total price = iphone_base_price+iphone_diff;
    private double iphone_citi_price;

    // extra price added to iphone_base_price. It is constant per city. Every
    // city has its own difference defined,
    private final double iphone_diff;

    private String cityName = "";

    // static final will be accessible everywhere within the class but cant be
    // changed once initialized.
    private static final String countryName = "India";

    public City(String cityName, double iphone_diff) {
        super();
        this.iphone_diff = iphone_diff;
        iphone_citi_price = iphone_base_price + iphone_diff;
        this.cityName = cityName;

    }

    /**
     * get phone price
     * 
     * @return
     */
    private double getPrice() {

        return iphone_citi_price;
    }

    /**
     * Get city name
     * 
     * @return
     */
    private String getCityName() {

        return cityName;
    }

    public static void main(String[] args) {

        // 300 is the
        City newyork = new City("Newyork", 300);
        System.out.println(newyork.getPrice() + "  " + newyork.getCityName());

        City california = new City("California", 800);
        System.out.println(california.getPrice() + "  " + california.getCityName());

        // We cant write below statement as a final variable can not be
        // reassigned
        // california.iphone_diff=1000; //************************

        // base price is defined for a class and not per instances.
        // For any number of object creation, static variable's value would be the same
        // for all instances until and unless changed.
        // Also it is accessible anywhere inside a class.
        iphone_base_price = 9000;

        City delhi = new City("delhi", 400);
        System.out.println(delhi.getPrice() + "  " + delhi.getCityName());

        City moscow = new City("delhi", 500);
        System.out.println(moscow.getPrice() + "  " + moscow.getCityName());

        // Here countryName is accessible as it is static but we can not change it as it is final as well. 
        //Something are meant to be accessible with no permission to modify it. 
        //Try un-commenting below statements
        System.out.println(countryName);

        // countryName="INDIA";
        // System.out.println(countryName);

    }

}

bardzo mało i statycznie

Nie ma dużej różnicy, ponieważ oba są stałymi. W przypadku większości obiektów danych klasy statyczny oznaczałby coś związanego z samą klasą, ponieważ istnieje tylko jedna kopia, bez względu na to, ile obiektów utworzono za pomocą nowego.

Ponieważ jest to stała, może nie być przechowywana ani w klasie, ani w instancji, ale kompilator nadal nie pozwoli ci uzyskać dostępu do obiektów instancji z metody statycznej, nawet jeśli wie, czym one byłyby. Istnienie interfejsu API odbicia może również wymagać bezsensownej pracy, jeśli nie zostanie on statyczny.

Ponieważ zmienna w klasie jest deklarowana jako końcowa ORAZ zainicjowana w tym samym poleceniu, nie ma absolutnie żadnego powodu, aby nie deklarować jej jako statycznej, ponieważ będzie miała tę samą wartość bez względu na instancję. Tak więc wszystkie instancje mogą dzielić ten sam adres pamięci dla wartości, oszczędzając w ten sposób czas przetwarzania, eliminując potrzebę tworzenia nowej zmiennej dla każdej instancji i oszczędzając pamięć, dzieląc 1 wspólny adres.

prywatny statyczny finał będzie uważany za stały, a do stałej można uzyskać dostęp tylko w tej klasie. Ponieważ uwzględniono słowo kluczowe static, wartość będzie stała dla wszystkich obiektów klasy.

wartość końcowa prywatnej zmiennej będzie podobna do stałej na obiekt.

Możesz odnieść się do java.lang.String lub poszukać przykładu poniżej.

public final class Foo
{

    private final int i;
    private static final int j=20;

    public Foo(int val){
        this.i=val;
    }

    public static void main(String[] args) {
        Foo foo1= new Foo(10);

        Foo foo2= new Foo(40);

        System.out.println(foo1.i);
        System.out.println(foo2.i);
        System.out.println(check.j);
    }
}

//Wynik:

10
40
20

Statyczny jest tym samym elementem we wszystkich instancjach klasy i samej klasie.
Non-static jest jednym dla każdej instancji (obiektu), a więc w swoim dokładnym przypadku to strata pamięci, jeśli nie umieścić statycznej.

Jeśli zaznaczysz tę zmienną jako statyczną, to jak wiesz, będziesz potrzebować metod statycznych, aby ponownie uzyskać dostęp do tych wartości, będzie to przydatne, jeśli już myślisz o użyciu tych zmiennych tylko w metodach statycznych. Jeśli tak jest, to byłby najlepszy.

Możesz jednak teraz ustawić zmienną jako publiczną, ponieważ nikt nie może jej modyfikować tak jak „System.out”, to znowu zależy od twoich intencji i tego, co chcesz osiągnąć.

Powiedzmy, że jeśli klasa nie będzie miała więcej niż jednej instancji, to która z nich zajmie więcej pamięci:

prywatny statyczny końcowy int ID = 250; lub prywatny końcowy int ID = 250;

Zrozumiałem, że statyczny będzie odnosił się do typu klasy z tylko jedną kopią w pamięci i niestatyczny będzie w nowej lokalizacji pamięci dla każdej zmiennej instancji. Jednak wewnętrznie, jeśli porównamy tylko 1 instancję tej samej klasy (tzn. Nie utworzy się więcej niż 1 instancja), to czy jest jakiś narzut związany z przestrzenią używaną przez 1 statyczną zmienną końcową?

Zmienna statyczna należy do klasy (co oznacza, że ​​wszystkie obiekty współużytkują tę zmienną). Zmienna niestatyczna należy do każdego obiektu.

public class ExperimentFinal {

private final int a;
private static final int b = 999; 

public ExperimentFinal(int a) {
    super();
    this.a = a;
}
public int getA() {
    return a;
}
public int getB() {
    return b;
}
public void print(int a, int b) {
    System.out.println("final int: " + a + " \nstatic final int: " + b);
}
public static void main(String[] args) {
    ExperimentFinal test = new ExperimentFinal(9);
    test.print(test.getA(), test.getB());
} }

Jak widać powyżej, dla „final int” możemy przypisać naszą zmienną do każdej instancji (obiektu) klasy, jednak dla „static int int” powinniśmy przypisać zmienną w klasie (zmienna statyczna należy do klasy ).

Jeśli użyjesz parametru static, wartość zmiennej będzie taka sama we wszystkich twoich instancjach, jeśli zmienisz się w jednej instancji, inne też się zmienią.

Ostateczne: po przypisaniu zmiennej końcowej zawsze zawiera tę samą wartość. wszędzie tam, gdzie zmienna jest statyczna lub niestatyczna: będzie tylko jedną zmienną dla wszystkich instancji zainicjowanych jeden raz w pamięci

To może pomóc

public class LengthDemo {
public static void main(String[] args) {
    Rectangle box = new Rectangle();
    System.out.println("Sending the value 10.0 "
            + "to the setLength method.");
    box.setLength(10.0);
    System.out.println("Done.");
    }
}

Słowo kluczowe „statyczny” sprawia, że ​​właściwość zmiennej jest klasą, a nie poszczególnymi instancjami klasy. Będzie jedna kopia tej zmiennej, która będzie współużytkowana przez wszystkie instancje tej klasy. Każda zmiana stanu zmiennej statycznej zostanie odzwierciedlona we wszystkich instancjach. Dodaj końcowy do statycznego, a otrzymamy zmienną, która została zainicjowana raz na zawsze w czasie ładowania klasy i nie może być później zmieniona przez żadną instancję klasy. Ostateczne zmienne statyczne należy zainicjować w czasie deklaracji, w przeciwnym razie wystąpi błąd czasu kompilacji. Jeśli chodzi o pole wystąpienia prywatnego, odnosi się ono do właściwości / stanu obiektu / wystąpienia klasy. Każde wystąpienie / obiekt klasy będzie miało własną kopię zmiennej wystąpienia. Gdy zmienna instancji zostanie zadeklarowana jako ostateczna, oznacza to, że nie możemy zmienić jego wartości dla tego wystąpienia. W tym celu musimy zainicjować zmienną końcową w deklaracji lub w konstruktorze. Jeśli nie zostanie wykonana w żadnej z nich, pojawi się błąd czasu kompilacji. Po zainicjowaniu, jeśli spróbujesz ponownie przypisać wartość, pojawi się błąd czasu kompilacji. Użyj statycznych zmiennych końcowych, w których dane będą udostępniane we wszystkich instancjach klasy, a chcesz, aby dane były tylko do odczytu. Użyj zmiennej końcowej instancji, jeśli chcesz reprezentować niektóre dane, które należą do każdej pojedynczej instancji klasy, ale tylko raz przechowywanych nie można zmienić. Użycie słowa kluczowego statycznego i instancji zależy od potrzeb projektowych i tego, co dane reprezentują w domenie. Jeśli dane są używane we wszystkich instancjach klasy, nie ma potrzeby oddzielnych odwołań do kopii / pamięci dla każdego obiektu. W tym celu musimy zainicjować zmienną końcową w deklaracji lub w konstruktorze. Jeśli nie zostanie wykonana w żadnej z nich, pojawi się błąd czasu kompilacji. Po zainicjowaniu, jeśli spróbujesz ponownie przypisać wartość, pojawi się błąd czasu kompilacji. Użyj statycznych zmiennych końcowych, w których dane będą udostępniane we wszystkich instancjach klasy, a chcesz, aby dane były tylko do odczytu. Użyj zmiennej końcowej instancji, jeśli chcesz reprezentować niektóre dane, które należą do każdej pojedynczej instancji klasy, ale tylko raz przechowywanych nie można zmienić. Użycie słowa kluczowego statycznego i instancji zależy od potrzeb projektowych i tego, co dane reprezentują w domenie. Jeśli dane są używane we wszystkich instancjach klasy, nie ma potrzeby oddzielnych odwołań do kopii / pamięci dla każdego obiektu. W tym celu musimy zainicjować zmienną końcową w deklaracji lub w konstruktorze. Jeśli nie zostanie wykonana w żadnej z nich, pojawi się błąd czasu kompilacji. Po zainicjowaniu, jeśli spróbujesz ponownie przypisać wartość, pojawi się błąd czasu kompilacji. Użyj statycznych zmiennych końcowych, w których dane będą udostępniane we wszystkich instancjach klasy, a chcesz, aby dane były tylko do odczytu. Użyj zmiennej końcowej instancji, jeśli chcesz reprezentować niektóre dane, które należą do każdej pojedynczej instancji klasy, ale tylko raz przechowywanych nie można zmienić. Użycie słowa kluczowego statycznego i instancji zależy od potrzeb projektowych i tego, co dane reprezentują w domenie. Jeśli dane są używane we wszystkich instancjach klasy, nie ma potrzeby oddzielnych odwołań do kopii / pamięci dla każdego obiektu. Jeśli nie zostanie wykonane w żadnym z nich, pojawi się błąd czasu kompilacji. Po zainicjowaniu, jeśli spróbujesz ponownie przypisać wartość, pojawi się błąd czasu kompilacji. Użyj statycznych zmiennych końcowych, w których dane będą udostępniane we wszystkich instancjach klasy, a chcesz, aby dane były tylko do odczytu. Użyj zmiennej końcowej instancji, jeśli chcesz reprezentować niektóre dane, które należą do każdej pojedynczej instancji klasy, ale tylko raz przechowywanych nie można zmienić. Użycie słowa kluczowego statycznego i instancji zależy od potrzeb projektowych i tego, co dane reprezentują w domenie. Jeśli dane są używane we wszystkich instancjach klasy, nie ma potrzeby oddzielnych odwołań do kopii / pamięci dla każdego obiektu. Jeśli nie zostanie wykonane w żadnym z nich, pojawi się błąd czasu kompilacji. Po zainicjowaniu, jeśli spróbujesz ponownie przypisać wartość, pojawi się błąd czasu kompilacji. Użyj statycznych zmiennych końcowych, w których dane będą udostępniane we wszystkich instancjach klasy, a chcesz, aby dane były tylko do odczytu. Użyj zmiennej końcowej instancji, jeśli chcesz reprezentować niektóre dane, które należą do każdej pojedynczej instancji klasy, ale tylko raz przechowywanych nie można zmienić. Użycie słowa kluczowego statycznego i instancji zależy od potrzeb projektowych i tego, co dane reprezentują w domenie. Jeśli dane są używane we wszystkich instancjach klasy, nie ma potrzeby oddzielnych odwołań do kopii / pamięci dla każdego obiektu. Użyj statycznych zmiennych końcowych, w których dane będą udostępniane we wszystkich instancjach klasy, a chcesz, aby dane były tylko do odczytu. Użyj zmiennej końcowej instancji, jeśli chcesz reprezentować niektóre dane, które należą do każdej pojedynczej instancji klasy, ale tylko raz przechowywanych nie można zmienić. Użycie słowa kluczowego statycznego i instancji zależy od potrzeb projektowych i tego, co dane reprezentują w domenie. Jeśli dane są używane we wszystkich instancjach klasy, nie ma potrzeby oddzielnych odwołań do kopii / pamięci dla każdego obiektu. Użyj statycznych zmiennych końcowych, w których dane będą udostępniane we wszystkich instancjach klasy, a chcesz, aby dane były tylko do odczytu. Użyj zmiennej końcowej instancji, jeśli chcesz reprezentować niektóre dane, które należą do każdej pojedynczej instancji klasy, ale tylko raz przechowywanych nie można zmienić. Użycie słowa kluczowego statycznego i instancji zależy od potrzeb projektowych i tego, co dane reprezentują w domenie. Jeśli dane są używane we wszystkich instancjach klasy, nie ma potrzeby oddzielnych odwołań do kopii / pamięci dla każdego obiektu. Użycie słowa kluczowego statycznego i instancji zależy od potrzeb projektowych i tego, co dane reprezentują w domenie. Jeśli dane są używane we wszystkich instancjach klasy, nie ma potrzeby oddzielnych odwołań do kopii / pamięci dla każdego obiektu. Użycie słowa kluczowego statycznego i instancji zależy od potrzeb projektowych i tego, co dane reprezentują w domenie. Jeśli dane są używane we wszystkich instancjach klasy, nie ma potrzeby oddzielnych odwołań do kopii / pamięci dla każdego obiektu.