özel nihai statik özellik vs özel nihai özellik

Java'da arasındaki fark nedir:

private final static int NUMBER = 10;

ve

private final int NUMBER = 10;

Her ikisi de privateve final, fark staticözniteliğidir.

Daha iyi olan ne? Ve neden?

Genel olarak, static" bir örnek yerine türün kendisiyle ilişkilendirilmiş" anlamına gelir .

Bu, daha önce türden bir örnek oluşturmadan statik bir değişkene başvurabileceğiniz anlamına gelir ve değişkene başvuran herhangi bir kod, aynı verilere atıfta bulunur. Bunu bir örnek değişkeniyle karşılaştırın: bu durumda, sınıfın her örneği için değişkenin bağımsız bir sürümü vardır. Yani mesela:

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

10 çıktı alır: y.instanceVariableve x.instanceVariableayrıdır, çünkü xvey farklı nesneler bakın.

Sen olabilir bunu yapmak için kötü bir fikir olsa da, referanslar yoluyla statik üyelere bakın. Yapsaydık:

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

bu 20 çıktısı alır - örnek başına bir tane değil, yalnızca bir değişken vardır. Bunu şu şekilde yazmak daha açık olurdu:

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

Bu davranışı çok daha belirgin hale getirir. Modern IDE'ler genellikle ikinci listenin üçüncü listeye değiştirilmesini önerecektir.

Aşağıdaki gibi değeri başlatan bir satır içi bildirime sahip olmak için hiçbir neden yoktur, çünkü her örnek kendi kendine sahip olur, NUMBERancak her zaman aynı değere sahiptir (değişmezdir ve değişmez bir değerle başlatılır). Bu, final statictüm örnekler için yalnızca bir değişkene sahip olmakla aynıdır .

private final int NUMBER = 10;

Bu nedenle değiştirilemezse, örnek başına bir kopyaya sahip olmanın bir anlamı yoktur.

Ancak, böyle bir yapıcıda başlatılırsa mantıklıdır:

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

Şimdi, her örneği MyClassiçin farklı ama değişmez bir değere sahip olabiliriz number.

İçin son başlatıldı zaman, zamanında farklı değerler atanabilir. Örneğin

Class Test{
  public final int a;
}

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

Böylece, her bir örnek a alanının farklı değerine sahiptir. .

İçin statik finali , tüm örnekleri aynı değeri paylaşan ve ilk başlatıldı sonra değiştirilemez.

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.

Bir staticdeğişken, uygulamanın tüm ömrü boyunca bellekte kalır ve sınıf yüklemesi sırasında başlatılır. staticHer newnesne oluşturduğunuzda değişken olmayan bir öğe başlatılıyor . Kullanmak genellikle daha iyidir:

private static final int NUMBER = 10;

Neden? Bu, örnek başına bellek kapladığı alanı azaltır. Muhtemelen önbellek isabetlerine de uygundur. Ve sadece mantıklı: staticbelirli bir türdeki (aka class) tüm örneklerde (aka nesneler) paylaşılan şeyler için kullanılmalıdır .

statik "sınıfla ilişkili" anlamına gelir; onsuz, değişken sınıfın her bir örneğiyle ilişkilendirilir. Statik ise, bellekte sadece bir tane olacağı anlamına gelir; değilse, oluşturduğunuz her örnek için bir tane olacaktır. statik, değişken yüklendiği sürece bellekte kalacağı anlamına gelir; onsuz, değişken örneğinde gc'd olabilir.

Cevapları okurken gerçek bir test bulamadım. İşte benim 2 sent:

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

}

İlk nesne için sonuçlar:

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

2. nesne için sonuçlar:

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

Sonuç:

Dediğim gibi java ilkel ve diğer tipler arasında bir fark yaratıyor. Java'daki ilkel türler her zaman "önbelleklenir", dizgi değişmezleri için aynıdır (yeni String nesneleri değil), bu nedenle statik ve statik olmayan üyeler arasında fark yoktur.

Ancak, statik olmayan üyeler ilkel türden bir örnek değilse bellek çoğaltması yapar.

ValueStatic değerini 10 olarak değiştirmek, Java iki int değişkenine aynı adresleri vereceğinden daha da ileri gidecektir.

Diğer cevaplar genellikle statik olmayan sabitleri kullanmanın bir nedeni olmadığını açıkça ortaya koysa da, sabit değişkenleri üzerinde farklı değerlere sahip çeşitli örneklere sahip olmanın mümkün olduğunu belirten kimseyi bulamadım.

Aşağıdaki örneği düşünün:

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

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

Üç TestClass örneği oluşturmak, aynı rastgele değeri üç kez yazdırır, çünkü yalnızca bir değer üretilir ve statik sabitte depolanır.

Ancak bunun yerine aşağıdaki örneği denerken:

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

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

Üç TestClass örneği oluşturmak artık üç farklı rastgele değer yazdırır, çünkü her örneğin kendi rastgele oluşturulmuş sabit değeri vardır.

Farklı durumlarda farklı sabit değerlere sahip olmanın gerçekten yararlı olacağı bir durum düşünemiyorum, ancak bunun statik ve statik olmayan finaller arasında açık bir fark olduğunu belirtmeye yardımcı olacağını umuyorum.

Jon'un daha önce de belirttiği gibi, sınıf değişkeni olarak da adlandırılan statik değişken, sınıf örnekleri arasında var olan bir değişkendir.

Burada bir örnek buldum :

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

Programın çıktısı aşağıda verilmiştir:

Bu örnekte görebildiğimiz gibi, her nesnenin kendi sınıf değişkeni kopyası vardır.

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

Yaptığım testlerden statik nihai değişkenler, nihai (statik olmayan) değişkenlerle aynı değildir! Nihai (statik olmayan) değişkenler nesneden nesneye değişebilir !!! Ancak bu sadece başlatma yapıcı içinde yapılırsa! (Yapıcıdan başlatılmazsa, oluşturulan her nesne için değiştirilemeyen nihai değişkenler oluşturduğundan, bu yalnızca bir bellek kaybıdır.)

Örneğin:

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

    }
}

Ekranda görünen şey:

Nesne Hakkında: A @ addbf1 Final: 14 Statik Final: 5

Nesne Hakkında: A @ 530daa Finali: 21 Statik Final: 5

İsimsiz 1. sınıf BT öğrencisi, Yunanistan

Ayrıca, statik final kullanırsanız Jon'un cevabına bir tür "tanım" gibi davranacaktır. Bunu kullanan sınıfı derledikten sonra, derlenmiş .class dosyasında yanmış olacaktır. Konuyla ilgili iş parçamı buradan kontrol edin .

Ana hedefiniz için: NUMBER'i ​​sınıfın farklı örneklerinde farklı şekilde kullanmıyorsanız, final ve statik kullanmanızı tavsiye ederim. (Vaka çalışmamın tanımladığı gibi olası sorunları düşünmeden derlenmiş sınıf dosyalarını kopyalamamayı unutmayın. Bu durumların çoğu gerçekleşmez, endişelenmeyin :))

Örneklerde farklı değerlerin nasıl kullanılacağını göstermek için bu kodu kontrol edin:

public class JustFinalAttr {
  public final int Number;

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

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

İşte iki sentim:

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

Misal:

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

Anahtar, değişkenlerin ve fonksiyonların farklı değerler döndürebilmesidir, bu nedenle son değişkenlere farklı değerlerle atanabilir.

Statik, statik son, son değişkenlerin kullanımını anlamak için bir başka basit örnek. Kod yorumları doğru bir açıklamaya sahiptir.

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

    }

}

çok az ve statik

İkisi de sabit olduğu için fazla bir fark yok. Çoğu sınıf veri nesnesi için, statik, sınıfın kendisiyle ilişkilendirilen bir şey anlamına gelir; yeni ile kaç nesne oluşturulmuş olursa olsun yalnızca bir kopya vardır.

Bir sabit olduğu için, aslında sınıfta veya bir örnekte depolanmayabilir, ancak derleyici, örnek nesnelere statik bir yöntemden, ne olacağını bilmelerine rağmen erişmenize izin vermez. Yansıma API'sinin varlığı, statik hale getirmezseniz de anlamsız bir çalışma gerektirebilir.

Sınıftaki bir değişken aynı komutta son VE BAŞLATILDI olarak bildirildiğinden, örneğe bakılmaksızın aynı değere sahip olacağından, statik olarak bildirmemek için kesinlikle hiçbir neden yoktur. Böylece, tüm örnekler bir değer için aynı bellek adresini paylaşabilir, böylece her örnek için yeni bir değişken oluşturma ihtiyacını ortadan kaldırarak işlem süresinden tasarruf edebilir ve 1 ortak adresi paylaşarak bellek tasarrufu yapabilirsiniz.

özel statik final sabit olarak kabul edilir ve sabitliğe yalnızca bu sınıfta erişilebilir. Statik anahtar kelimesi içerdiğinden, değer sınıfın tüm nesneleri için sabit olacaktır.

özel son değişken değeri, nesne başına sabit gibi olacaktır.

Java.lang.String dosyasına başvurabilir veya aşağıdaki örneği arayabilirsiniz.

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

//Çıktı:

10
40
20

Statik olan tüm sınıf örneklerinde ve sınıfın kendisinde aynı üyedir.
Statik olmayan bu yüzden de, her örneği (nesne) için biridir kesin bir durumda eğer o bellek kaybıdır yok statik koydu.

Bu değişkeni statik olarak bildiğiniz gibi işaretlerseniz, bu değerlere tekrar erişmek için statik yöntemlere gereksinim duyarsınız, bu değişkenleri yalnızca statik yöntemlerde kullanmayı düşünüyorsanız, bu yararlı olacaktır. Eğer öyleyse, o zaman bu en iyisi olurdu.

Ancak değişkeni şimdi herkese açık yapabilirsiniz, çünkü hiç kimse bunu "System.out" gibi değiştiremez, yine niyetlerinize ve neye ulaşmak istediğinize bağlıdır.

Diyelim ki sınıfın birden fazla örneği olmayacak, hangisinin daha fazla bellek alacağını söyleyelim:

özel statik son int ID = 250; veya özel nihai int ID = 250;

Statik, bellekte sadece bir kopya ile sınıf türüne atıfta bulunacağını ve statik olmayan her örnek değişkeni için yeni bir bellek konumunda olacağını anladım. Ancak, dahili olarak aynı sınıfın 1 örneğini şimdiye kadar karşılaştırırsak (yani 1'den fazla örnek oluşturulamaz), o zaman 1 statik son değişken tarafından kullanılan alan açısından herhangi bir ek yük var mı?

Statik değişken sınıfa aittir (yani tüm nesneler bu değişkeni paylaşır). Statik olmayan değişken her nesneye aittir.

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

Yukarıdaki örneği görebileceğiniz gibi, "final int" için değişkenimizi sınıfın her örneği (nesnesi) için atayabiliriz, ancak "statik final int" için sınıfta bir değişken atamalıyız (statik değişken sınıfa aittir ).

Statik kullanırsanız, değişkenin değeri tüm örneklerinizde aynı olur, bir durumda değiştirilirse diğerleri de değişir.

Son: Son bir değişken atandığında, her zaman aynı değeri içerir. değişkenin statik olduğu veya statik olmadığı her yerde: bellekte bir kez başlatılan tüm örnekler için yalnızca bir değişken olacaktır

Bu yardımcı olabilir

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

"Statik" anahtar kelime, sınıfın tek tek örnekleri yerine değişkenin değişken özelliğini oluşturur. Bu değişkenin, sınıfın tüm örnekleri arasında paylaşılan bir kopyası olacaktır. Statik değişkenin durumundaki herhangi bir değişiklik tüm örneklere yansıtılacaktır. Statik için final ekleyin ve bir kez ve herkes için sınıf yükleme zamanında başlatılan ve daha sonra sınıfın herhangi bir örneği tarafından değiştirilemeyen bir değişken elde ederiz. Statik son değişkenlerin bildirim zamanında başlatılması gerekir, aksi takdirde derleme zamanı hatası veririz. Özel örnek alanı söz konusu olduğunda, bir nesnenin / sınıf örneğinin özelliğini / durumunu ifade eder. Sınıfın her örneğinin / nesnesinin kendi örnek değişkeni kopyası olacaktır. Örnek değişkeni nihai olarak bildirildiğinde, yani bu örnek için değerini değiştiremeyiz. Bunun için son değişkeni ya bildirimde ya da yapıcıda başlatmamız gerekir.Her ikisinde de yapılmazsa, derleme zamanı hatası gösterilecektir. Başlatıldıktan sonra, bir değeri yeniden atamaya çalışırsanız derleme zamanı hatası alırsınız. Verilerin sınıfın tüm örnekleri arasında paylaşılacağı ve verilerin salt okunur olmasını istediğiniz statik son değişkenleri kullanın. Sınıfın her bir örneğine ait olan, ancak bir kez ait bazı verileri temsil etmek istiyorsanız, örnek son değişkenini kullanın kaydedilemez. Statik ve örnek anahtar kelimenin kullanımı, tasarım gereksinimlerinize ve bu verilerin etki alanında neyi temsil ettiğine bağlıdır. Veriler sınıf örnekleri arasında kullanılırsa, her nesne için ayrı kopyalara / bellek referanslarına gerek yoktur. Bunun için son değişkeni ya bildirimde ya da yapıcıda başlatmamız gerekir.Her ikisinde de yapılmazsa, derleme zamanı hatası gösterilecektir. Başlatıldıktan sonra, bir değeri yeniden atamaya çalışırsanız derleme zamanı hatası alırsınız. Verilerin sınıfın tüm örnekleri arasında paylaşılacağı ve verilerin salt okunur olmasını istediğiniz statik son değişkenleri kullanın. Sınıfın her bir örneğine ait olan, ancak bir kez ait bazı verileri temsil etmek istiyorsanız, örnek son değişkenini kullanın kaydedilemez. Statik ve örnek anahtar kelimenin kullanımı, tasarım gereksinimlerinize ve bu verilerin etki alanında neyi temsil ettiğine bağlıdır. Veriler sınıf örnekleri arasında kullanılırsa, her nesne için ayrı kopyalara / bellek referanslarına gerek yoktur. Bunun için son değişkeni ya bildirimde ya da yapıcıda başlatmamız gerekir.Her ikisinde de yapılmazsa, derleme zamanı hatası gösterilecektir. Başlatıldıktan sonra, bir değeri yeniden atamaya çalışırsanız derleme zamanı hatası alırsınız. Verilerin sınıfın tüm örnekleri arasında paylaşılacağı ve verilerin salt okunur olmasını istediğiniz statik son değişkenleri kullanın. Sınıfın her bir örneğine ait olan, ancak bir kez ait bazı verileri temsil etmek istiyorsanız, örnek son değişkenini kullanın kaydedilemez. Statik ve örnek anahtar kelimenin kullanımı, tasarım gereksinimlerinize ve bu verilerin etki alanında neyi temsil ettiğine bağlıdır. Veriler sınıf örnekleri arasında kullanılırsa, her nesne için ayrı kopyalara / bellek referanslarına gerek yoktur. Her ikisinde de yapılmazsa, derleme zamanı hatası gösterilir. Başlatıldıktan sonra, bir değeri yeniden atamaya çalışırsanız derleme zamanı hatası alırsınız. Verilerin sınıfın tüm örnekleri arasında paylaşılacağı ve verilerin salt okunur olmasını istediğiniz statik son değişkenleri kullanın. Sınıfın her bir örneğine ait olan, ancak bir kez ait bazı verileri temsil etmek istiyorsanız, örnek son değişkenini kullanın kaydedilemez. Statik ve örnek anahtar kelimenin kullanımı, tasarım gereksinimlerinize ve bu verilerin etki alanında neyi temsil ettiğine bağlıdır. Veriler sınıf örnekleri arasında kullanılırsa, her nesne için ayrı kopyalara / bellek referanslarına gerek yoktur. Her ikisinde de yapılmazsa, derleme zamanı hatası gösterilir. Başlatıldıktan sonra, bir değeri yeniden atamaya çalışırsanız derleme zamanı hatası alırsınız. Verilerin sınıfın tüm örnekleri arasında paylaşılacağı ve verilerin salt okunur olmasını istediğiniz statik son değişkenleri kullanın. Sınıfın her bir örneğine ait olan, ancak bir kez ait bazı verileri temsil etmek istiyorsanız, örnek son değişkenini kullanın kaydedilemez. Statik ve örnek anahtar kelimenin kullanımı, tasarım gereksinimlerinize ve bu verilerin etki alanında neyi temsil ettiğine bağlıdır. Veriler sınıf örnekleri arasında kullanılırsa, her nesne için ayrı kopyalara / bellek referanslarına gerek yoktur. Verilerin sınıfın tüm örnekleri arasında paylaşılacağı ve verilerin salt okunur olmasını istediğiniz statik son değişkenleri kullanın. Sınıfın her bir örneğine ait olan, ancak bir kez ait bazı verileri temsil etmek istiyorsanız, örnek son değişkenini kullanın kaydedilemez. Statik ve örnek anahtar kelimenin kullanımı, tasarım gereksinimlerinize ve bu verilerin etki alanında neyi temsil ettiğine bağlıdır. Veriler sınıf örnekleri arasında kullanılırsa, her nesne için ayrı kopyalara / bellek referanslarına gerek yoktur. Verilerin sınıfın tüm örnekleri arasında paylaşılacağı ve verilerin salt okunur olmasını istediğiniz statik son değişkenleri kullanın. Sınıfın her bir örneğine ait olan, ancak bir kez ait bazı verileri temsil etmek istiyorsanız, örnek son değişkenini kullanın kaydedilemez. Statik ve örnek anahtar kelimenin kullanımı, tasarım gereksinimlerinize ve bu verilerin etki alanında neyi temsil ettiğine bağlıdır. Veriler sınıf örnekleri arasında kullanılırsa, her nesne için ayrı kopyalara / bellek referanslarına gerek yoktur. Statik ve örnek anahtar kelimenin kullanımı, tasarım gereksinimlerinize ve bu verilerin etki alanında neyi temsil ettiğine bağlıdır. Veriler sınıf örnekleri arasında kullanılırsa, her nesne için ayrı kopyalara / bellek referanslarına gerek yoktur. Statik ve örnek anahtar kelimenin kullanımı, tasarım gereksinimlerinize ve bu verilerin etki alanında neyi temsil ettiğine bağlıdır. Veriler sınıf örnekleri arasında kullanılırsa, her nesne için ayrı kopyalara / bellek referanslarına gerek yoktur.