privates endgültiges statisches Attribut vs privates endgültiges Attribut

Was ist in Java der Unterschied zwischen:

private final static int NUMBER = 10;

und

private final int NUMBER = 10;

Beide sind privateund final, der Unterschied ist das staticAttribut.

Was ist besser? Und warum?

Im Allgemeinen staticbedeutet "dem Typ selbst zugeordnet und nicht einer Instanz des Typs".

Das heißt, Sie können auf eine statische Variable verweisen, ohne jemals eine Instanz dieses Typs erstellt zu haben, und jeder Code, der auf die Variable verweist, verweist auf genau dieselben Daten. Vergleichen Sie dies mit einer Instanzvariablen: In diesem Fall gibt es eine unabhängige Version der Variablen pro Instanz der Klasse. Also zum Beispiel:

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

druckt 10 aus: y.instanceVariableund x.instanceVariablesind getrennt, weil xund ybeziehen sich auf verschiedene Objekte.

Sie können über Referenzen auf statische Mitglieder verweisen, obwohl dies eine schlechte Idee ist. Wenn wir das taten:

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

dann würde das 20 ausdrucken - es gibt nur eine Variable, keine pro Instanz. Es wäre klarer gewesen, dies zu schreiben als:

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

Das macht das Verhalten viel offensichtlicher. Moderne IDEs schlagen normalerweise vor, die zweite Auflistung in die dritte zu ändern.

Es gibt keinen Grund für eine Inline-Deklaration, die den Wert wie folgt initialisiert, da jede Instanz ihren eigenen NUMBERWert hat, jedoch immer denselben Wert hat (unveränderlich und mit einem Literal initialisiert). Dies ist dasselbe, als nur eine final staticVariable für alle Instanzen zu haben.

private final int NUMBER = 10;

Wenn es sich nicht ändern kann, macht es keinen Sinn, eine Kopie pro Instanz zu haben.

Es ist jedoch sinnvoll, wenn es in einem Konstruktor wie diesem initialisiert wird:

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

Jetzt MyClasskönnen wir für jede Instanz von einen anderen, aber unveränderlichen Wert von haben number.

Zum Schluss können bei der Initialisierung zur Laufzeit unterschiedliche Werte zugewiesen werden. Beispielsweise

Class Test{
  public final int a;
}

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

Somit hat jede Instanz einen anderen Wert von Feld a .

Für das statische Finale haben alle Instanzen denselben Wert und können nach der ersten Initialisierung nicht mehr geändert werden.

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.

Eine staticVariable bleibt während der gesamten Lebensdauer der Anwendung im Speicher und wird beim Laden der Klasse initialisiert. staticJedes Mal, wenn Sie ein newObjekt erstellen , wird eine Nichtvariable initialisiert . Es ist im Allgemeinen besser zu verwenden:

private static final int NUMBER = 10;

Warum? Dies reduziert den Speicherbedarf pro Instanz. Es ist möglicherweise auch günstig für Cache-Treffer. Und es macht einfach Sinn: staticsollte für Dinge verwendet werden, die von allen Instanzen (auch bekannt als Objekte) eines bestimmten Typs (auch bekannt als class) gemeinsam genutzt werden.

statisch bedeutet "der Klasse zugeordnet"; Ohne sie ist die Variable jeder Instanz der Klasse zugeordnet. Wenn es statisch ist, bedeutet dies, dass Sie nur eines im Speicher haben. Wenn nicht, haben Sie eine für jede von Ihnen erstellte Instanz. statisch bedeutet, dass die Variable so lange im Speicher bleibt, wie die Klasse geladen wird. Ohne sie kann die Variable gc'd werden, wenn ihre Instanz ist.

Als ich die Antworten las, fand ich keinen wirklichen Test, der wirklich auf den Punkt kam. Hier sind meine 2 Cent:

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

}

Ergebnisse für das erste Objekt:

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

Ergebnisse für 2. Objekt:

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

Fazit :

Wie ich dachte, macht Java einen Unterschied zwischen primitiven und anderen Typen. Primitive Typen in Java werden immer "zwischengespeichert", genau wie Zeichenfolgenliterale (keine neuen Zeichenfolgenobjekte), sodass kein Unterschied zwischen statischen und nicht statischen Elementen besteht.

Es gibt jedoch eine Speicherduplizierung für nicht statische Elemente, wenn sie keine Instanz eines primitiven Typs sind.

Das Ändern des Werts von valueStatic in 10 geht sogar noch weiter, da Java den beiden int-Variablen die gleichen Adressen gibt.

Während die anderen Antworten ziemlich klar zu machen scheinen, dass es im Allgemeinen keinen Grund gibt, nicht statische Konstanten zu verwenden, konnte ich niemanden finden, der darauf hinweist, dass es möglich ist, verschiedene Instanzen mit unterschiedlichen Werten für ihre konstanten Variablen zu haben.

Betrachten Sie das folgende Beispiel:

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

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

Wenn Sie drei Instanzen von TestClass erstellen, wird derselbe Zufallswert dreimal gedruckt, da nur ein Wert generiert und in der statischen Konstante gespeichert wird.

Wenn Sie jedoch stattdessen das folgende Beispiel ausprobieren:

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

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

Das Erstellen von drei Instanzen von TestClass würde jetzt drei verschiedene Zufallswerte drucken, da jede Instanz ihren eigenen zufällig generierten konstanten Wert hat.

Ich kann mir keine Situation vorstellen, in der es wirklich nützlich wäre, unterschiedliche konstante Werte für unterschiedliche Instanzen zu haben, aber ich hoffe, dies hilft darauf hinzuweisen, dass es einen deutlichen Unterschied zwischen statischen und nicht statischen Endspielen gibt.

Wie Jon bereits sagte, ist eine statische Variable, die auch als Klassenvariable bezeichnet wird, eine Variable, die über Instanzen einer Klasse hinweg existiert.

Ich habe hier ein Beispiel dafür gefunden :

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

Die Ausgabe des Programms ist unten angegeben:

Wie wir in diesem Beispiel sehen können, hat jedes Objekt eine eigene Kopie der Klassenvariablen.

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

Nach den von mir durchgeführten Tests sind statische Endvariablen nicht mit endgültigen (nicht statischen) Variablen identisch! Endgültige (nicht statische) Variablen können von Objekt zu Objekt unterschiedlich sein !!! Dies ist jedoch nur möglich, wenn die Initialisierung im Konstruktor erfolgt! (Wenn es nicht vom Konstruktor initialisiert wird, ist es nur eine Verschwendung von Speicher, da für jedes erstellte Objekt endgültige Variablen erstellt werden, die nicht geändert werden können.)

Zum Beispiel:

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

    }
}

Was auf dem Bildschirm angezeigt wird, ist:

Über das Objekt: A @ addbf1 Finale: 14 Statisches Finale: 5

Über das Objekt: A @ 530daa Finale: 21 Statisches Finale: 5

Anonymer IT-Student im ersten Jahr, Griechenland

Wenn Sie das statische Finale verwenden, verhält sich Jon zu einer Art "Definition". Sobald Sie die Klasse kompiliert haben, die sie verwendet, wird sie in der kompilierten .class-Datei gebrannt. Überprüfen Sie meinen Thread darüber hier .

Für Ihr Hauptziel: Wenn Sie die NUMMER in den verschiedenen Instanzen der Klasse nicht unterschiedlich verwenden, würde ich empfehlen, final und static zu verwenden. (Sie müssen nur bedenken, keine kompilierten Klassendateien zu kopieren, ohne mögliche Probleme zu berücksichtigen, wie sie in meiner Fallstudie beschrieben werden. In den meisten Fällen tritt dies nicht auf, keine Sorge :))

Überprüfen Sie diesen Code, um zu zeigen, wie Sie verschiedene Werte in Instanzen verwenden:

public class JustFinalAttr {
  public final int Number;

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

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

Hier sind meine zwei Cent:

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

Beispiel:

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

Der Schlüssel ist, dass Variablen und Funktionen unterschiedliche Werte zurückgeben können. Daher können endgültige Variablen mit unterschiedlichen Werten zugewiesen werden.

Nur ein weiteres einfaches Beispiel, um die Verwendung statischer, statischer endgültiger und endgültiger Variablen zu verstehen. Codekommentare haben die richtige Erklärung.

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

    }

}

sehr wenig und statisch

Es gibt keinen großen Unterschied, da beide Konstanten sind. Für die meisten Klassendatenobjekte würde statisch etwas bedeuten, das der Klasse selbst zugeordnet ist, da nur eine Kopie vorhanden ist, unabhängig davon, wie viele Objekte mit new erstellt wurden.

Da es sich um eine Konstante handelt, wird sie möglicherweise weder in der Klasse noch in einer Instanz gespeichert, aber der Compiler lässt Sie dennoch nicht über eine statische Methode auf Instanzobjekte zugreifen, selbst wenn er weiß, um welche es sich handelt. Das Vorhandensein der Reflection-API erfordert möglicherweise auch sinnlose Arbeit, wenn Sie sie nicht statisch machen.

Da eine Variable in einer Klasse im selben Befehl als endgültig UND initialisiert deklariert wird, gibt es absolut keinen Grund, sie nicht als statisch zu deklarieren, da sie unabhängig von der Instanz denselben Wert hat. Somit können alle Instanzen dieselbe Speicheradresse für einen Wert gemeinsam nutzen, wodurch Verarbeitungszeit gespart wird, da keine neue Variable für jede Instanz erstellt werden muss, und Speicherplatz gespart wird, indem eine gemeinsame Adresse gemeinsam genutzt wird.

private static final wird als Konstante betrachtet und auf die Konstante kann nur innerhalb dieser Klasse zugegriffen werden. Da das Schlüsselwort static enthalten ist, ist der Wert für alle Objekte der Klasse konstant.

Der private endgültige Variablenwert entspricht der Konstanten pro Objekt.

Sie können auf java.lang.String verweisen oder nach dem folgenden Beispiel suchen.

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

//Ausgabe:

10
40
20

Das statische Mitglied ist in allen Klasseninstanzen und in der Klasse selbst dasselbe Mitglied.
Das Nicht-Statische ist eines für jede Instanz (Objekt). In Ihrem genauen Fall ist es also eine Verschwendung von Speicher, wenn Sie kein Statisches setzen.

Wenn Sie diese Variable als statisch markieren, benötigen Sie, wie Sie wissen, statische Methoden, um erneut auf diese Werte zuzugreifen. Dies ist hilfreich, wenn Sie bereits daran denken, diese Variablen nur in statischen Methoden zu verwenden. Wenn dies so ist, wäre dies der beste.

Sie können die Variable jetzt jedoch als öffentlich festlegen, da niemand sie wie "System.out" ändern kann. Dies hängt wiederum von Ihren Absichten und dem ab, was Sie erreichen möchten.

Nehmen wir an, wenn die Klasse nie mehr als eine Instanz hat, welche benötigt dann mehr Speicher:

private static final int ID = 250; oder private final int ID = 250;

Ich habe verstanden, dass sich statisch auf den Klassentyp mit nur einer Kopie im Speicher bezieht und nicht statisch sich für jede Instanzvariable an einem neuen Speicherort befindet. Wenn wir jedoch intern nur eine Instanz derselben Klasse jemals vergleichen (dh es würde nicht mehr als eine Instanz erstellt werden), gibt es dann einen Overhead in Bezug auf den von einer statischen Endvariablen verwendeten Speicherplatz?

Die statische Variable gehört zur Klasse (dh alle Objekte teilen sich diese Variable). Zu jedem Objekt gehört eine nicht statische Variable.

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

Wie Sie im obigen Beispiel sehen können, können wir für "final int" unsere Variable für jede Instanz (Objekt) der Klasse zuweisen. Für "static final int" sollten wir jedoch eine Variable in der Klasse zuweisen (statische Variable gehört zur Klasse ).

Wenn Sie static verwenden, ist der Wert der Variablen in allen Instanzen gleich. Wenn er in einer Instanz geändert wird, ändern sich auch die anderen.

Final: Sobald eine endgültige Variable zugewiesen wurde, enthält sie immer denselben Wert. Überall dort, wo die Variable statisch oder nicht statisch ist: Es handelt sich nur um eine Variable für alle Instanzen, die einmal im Speicher initialisiert wurden

Dies könnte helfen

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.");
    }
}

Das Schlüsselwort "Static" macht die Variableigenschaft der Klasse und nicht einzelne Instanzen der Klasse. Es wird eine Kopie dieser Variablen geben, die von allen Instanzen dieser Klasse gemeinsam genutzt wird. Jede Änderung des Status der statischen Variablen wird in allen Instanzen berücksichtigt. Wenn Sie final zu static hinzufügen, erhalten Sie eine Variable, die zum Zeitpunkt des Ladens der Klasse ein für alle Mal initialisiert wurde und später von keiner Instanz der Klasse geändert werden kann. Statische endgültige Variablen müssen zum Deklarationszeitpunkt initialisiert werden, da sonst ein Fehler bei der Kompilierung auftritt. Das Feld für private Instanzen bezieht sich auf die Eigenschaft / den Status eines Objekts / einer Instanz einer Klasse. Jede Instanz / jedes Objekt der Klasse verfügt über eine eigene Kopie der Instanzvariablen. Wenn die Instanzvariable als endgültig deklariert wird, Dies bedeutet, dass wir den Wert für diese Instanz nicht ändern können. Dazu müssen wir die endgültige Variable entweder bei der Deklaration oder im Konstruktor initialisieren. Wenn dies in keinem von beiden der Fall ist, wird ein Fehler bei der Kompilierung angezeigt. Wenn Sie nach der Initialisierung versuchen, einen Wert neu zuzuweisen, wird ein Fehler bei der Kompilierung angezeigt. Verwenden Sie statische Endvariablen, bei denen die Daten für alle Instanzen der Klasse gemeinsam genutzt werden und die Daten schreibgeschützt sein sollen. Verwenden Sie die Endvariable der Instanz, wenn Sie einige Daten darstellen möchten, die zu jeder einzelnen Instanz der Klasse gehören, jedoch nur einmal gespeichert kann nicht geändert werden. Die Verwendung von statischen und Instanzschlüsselwörtern hängt von Ihren Entwurfsanforderungen und der Darstellung dieser Daten in der Domäne ab. Wenn die Daten für alle Klasseninstanzen verwendet werden, sind keine einzelnen Kopien / Speicherreferenzen für jedes Objekt erforderlich. Dazu müssen wir die endgültige Variable entweder bei der Deklaration oder im Konstruktor initialisieren. Wenn dies in keinem von beiden der Fall ist, wird ein Fehler bei der Kompilierung angezeigt. Wenn Sie nach der Initialisierung versuchen, einen Wert neu zuzuweisen, wird ein Fehler bei der Kompilierung angezeigt. Verwenden Sie statische Endvariablen, bei denen die Daten für alle Instanzen der Klasse gemeinsam genutzt werden und die Daten schreibgeschützt sein sollen. Verwenden Sie die Endvariable der Instanz, wenn Sie einige Daten darstellen möchten, die zu jeder einzelnen Instanz der Klasse gehören, jedoch nur einmal gespeichert kann nicht geändert werden. Die Verwendung von statischen und Instanzschlüsselwörtern hängt von Ihren Entwurfsanforderungen und der Darstellung dieser Daten in der Domäne ab. Wenn die Daten für alle Klasseninstanzen verwendet werden, sind keine einzelnen Kopien / Speicherreferenzen für jedes Objekt erforderlich. Dazu müssen wir die endgültige Variable entweder bei der Deklaration oder im Konstruktor initialisieren. Wenn dies in keinem von beiden der Fall ist, wird ein Fehler bei der Kompilierung angezeigt. Wenn Sie nach der Initialisierung versuchen, einen Wert neu zuzuweisen, wird ein Fehler bei der Kompilierung angezeigt. Verwenden Sie statische Endvariablen, bei denen die Daten für alle Instanzen der Klasse gemeinsam genutzt werden und die Daten schreibgeschützt sein sollen. Verwenden Sie die Endvariable der Instanz, wenn Sie einige Daten darstellen möchten, die zu jeder einzelnen Instanz der Klasse gehören, jedoch nur einmal gespeichert kann nicht geändert werden. Die Verwendung von statischen und Instanzschlüsselwörtern hängt von Ihren Entwurfsanforderungen und der Darstellung dieser Daten in der Domäne ab. Wenn die Daten für alle Klasseninstanzen verwendet werden, sind keine einzelnen Kopien / Speicherreferenzen für jedes Objekt erforderlich. Wenn dies in keinem von beiden der Fall ist, wird ein Fehler bei der Kompilierung angezeigt. Wenn Sie nach der Initialisierung versuchen, einen Wert neu zuzuweisen, wird ein Fehler bei der Kompilierung angezeigt. Verwenden Sie statische Endvariablen, bei denen die Daten für alle Instanzen der Klasse gemeinsam genutzt werden und die Daten schreibgeschützt sein sollen. Verwenden Sie die Endvariable der Instanz, wenn Sie einige Daten darstellen möchten, die zu jeder einzelnen Instanz der Klasse gehören, jedoch nur einmal gespeichert kann nicht geändert werden. Die Verwendung von statischen und Instanzschlüsselwörtern hängt von Ihren Entwurfsanforderungen und der Darstellung dieser Daten in der Domäne ab. Wenn die Daten für alle Klasseninstanzen verwendet werden, sind keine einzelnen Kopien / Speicherreferenzen für jedes Objekt erforderlich. Wenn dies in keinem von beiden der Fall ist, wird ein Fehler bei der Kompilierung angezeigt. Wenn Sie nach der Initialisierung versuchen, einen Wert neu zuzuweisen, wird ein Fehler bei der Kompilierung angezeigt. Verwenden Sie statische Endvariablen, bei denen die Daten für alle Instanzen der Klasse gemeinsam genutzt werden und die Daten schreibgeschützt sein sollen. Verwenden Sie die Endvariable der Instanz, wenn Sie einige Daten darstellen möchten, die zu jeder einzelnen Instanz der Klasse gehören, jedoch nur einmal gespeichert kann nicht geändert werden. Die Verwendung von statischen und Instanzschlüsselwörtern hängt von Ihren Entwurfsanforderungen und der Darstellung dieser Daten in der Domäne ab. Wenn die Daten für alle Klasseninstanzen verwendet werden, sind keine einzelnen Kopien / Speicherreferenzen für jedes Objekt erforderlich. Verwenden Sie statische Endvariablen, bei denen die Daten für alle Instanzen der Klasse gemeinsam genutzt werden und die Daten schreibgeschützt sein sollen. Verwenden Sie die Endvariable der Instanz, wenn Sie einige Daten darstellen möchten, die zu jeder einzelnen Instanz der Klasse gehören, jedoch nur einmal gespeichert kann nicht geändert werden. Die Verwendung von statischen und Instanzschlüsselwörtern hängt von Ihren Entwurfsanforderungen und der Darstellung dieser Daten in der Domäne ab. Wenn die Daten für alle Klasseninstanzen verwendet werden, sind keine einzelnen Kopien / Speicherreferenzen für jedes Objekt erforderlich. Verwenden Sie statische Endvariablen, bei denen die Daten für alle Instanzen der Klasse gemeinsam genutzt werden und die Daten schreibgeschützt sein sollen. Verwenden Sie die Endvariable der Instanz, wenn Sie einige Daten darstellen möchten, die zu jeder einzelnen Instanz der Klasse gehören, jedoch nur einmal gespeichert kann nicht geändert werden. Die Verwendung von statischen und Instanzschlüsselwörtern hängt von Ihren Entwurfsanforderungen und der Darstellung dieser Daten in der Domäne ab. Wenn die Daten für alle Klasseninstanzen verwendet werden, sind keine einzelnen Kopien / Speicherreferenzen für jedes Objekt erforderlich. Die Verwendung von statischen und Instanzschlüsselwörtern hängt von Ihren Entwurfsanforderungen und der Darstellung dieser Daten in der Domäne ab. Wenn die Daten für alle Klasseninstanzen verwendet werden, sind keine einzelnen Kopien / Speicherreferenzen für jedes Objekt erforderlich. Die Verwendung von statischen und Instanzschlüsselwörtern hängt von Ihren Entwurfsanforderungen und der Darstellung dieser Daten in der Domäne ab. Wenn die Daten für alle Klasseninstanzen verwendet werden, sind keine einzelnen Kopien / Speicherreferenzen für jedes Objekt erforderlich.