Java'da özel bir statik değişkenin kullanımı nedir?

Bir değişken olarak bildirilirse, değişkene public static varName;her yerden erişebilirim ClassName.varName. Ayrıca statik üyelerin bir sınıfın tüm örnekleri tarafından paylaşıldığını ve her durumda yeniden tahsis edilmediğinin farkındayım.

Değişken private static varName;bildirmek, değişken bildirmekten farklı private varName;mıdır?

Her iki durumda da başka bir sınıftan ClassName.varNameveya ClassInstance.varNamebaşka bir sınıftan erişilemez .

Değişkenin statik olarak bildirilmesi, ona başka özel özellikler sağlıyor mu?

Tabii ki ClassName.var_name, ancak tanımlandığı sınıfın içinden erişilebilir - bunun nedeni, olarak tanımlanmasıdır private.

public staticveya private staticdeğişkenler genellikle sabitler için kullanılır. Örneğin, birçok kişi kodlarında sabit kodları "sabit kodlamak" istemez; anlamlı bir isme sahip bir public staticveya private staticdeğişken yapmaktan ve kodlarında bunu daha okunabilir hale getirecek şekilde kullanmaktan hoşlanırlar . (Bu tür sabitleri de yapmalısınız final).

Örneğin:

public class Example {
    private final static String JDBC_URL = "jdbc:mysql://localhost/shopdb";
    private final static String JDBC_USERNAME = "username";
    private final static String JDBC_PASSWORD = "password";

    public static void main(String[] args) {
        Connection conn = DriverManager.getConnection(JDBC_URL,
                                         JDBC_USERNAME, JDBC_PASSWORD);

        // ...
    }
}

Bunu yapıp yapmadığınız publicveya privatedeğişkenlerin sınıfın dışında görünmesini isteyip istemediğinize bağlıdır.

Statik değişkenlerin bir sınıfın tüm örnekleri için tek bir değeri vardır.

Eğer şöyle bir şey yaparsanız:

public class Person
{
    private static int numberOfEyes;
    private String name;
}

ve sonra isminizi değiştirmek istediniz, bu iyi, benim adım aynı kalıyor. Bununla birlikte, 17 gözünüz olacak şekilde değiştirmek isterseniz, dünyadaki herkesin de 17 gözü olacaktır.

Özel statik değişkenler, özel yönetim ortamı değişkenlerinin faydalı olduğu şekilde kullanışlıdır: yalnızca aynı sınıftaki kodla erişilen durumu depolarlar. Değişkenin erişilebilirliği (özel / genel / vb.) Ve örnek / statik doğası tamamen dikey kavramlardır.

Statik değişkenlerin sınıfın "tüm örnekleri" arasında paylaşıldığını düşünmekten kaçınırım - bu durumun mevcut olması için en az bir örnek olması gerektiğini gösterir. Hayır - statik bir değişken, türün herhangi bir örneği yerine türün kendisiyle ilişkilendirilir .

Bu nedenle, belirli bir örnek yerine türle ilişkilendirilmiş bir durum istediğinizde ve bu durumu gizli tutmak istediğinizde (örneğin, özelliklerle kontrollü erişime izin vermek istediğinizde) özel bir statik değişken olması mantıklıdır.

Bir kenara, şiddetle tavsiye ederim sadece değişmez türleri statik nihai değişkenleri - Halka açık (hatta özel olmayan) olan sabitleri yapmak değişkenlerin yazın. API ve uygulamayı (diğer şeylerin yanı sıra) ayırmak için her şey özel olmalıdır.

Haklısın, genel statik değişkenler sınıfın bir örneği olmadan kullanılır, ancak özel statik değişkenler değildir. Onlarla özel statik değişkenleri nerede kullandığım arasındaki temel fark, statik işlevde bir değişken kullanmanız gerektiğidir. Statik işlevler için yalnızca statik değişkenleri kullanabilirsiniz, böylece onları diğer sınıflardan erişmemek için özel yaparsınız. Özel statik için kullandığım tek durum bu.

İşte bir örnek:

Class test {
   public static String name = "AA";
   private static String age;

   public static void setAge(String yourAge) {
       //here if the age variable is not static you will get an error that you cannot access non static variables from static procedures so you have to make it static and private to not be accessed from other classes
       age = yourAge;
   }
}

Eh, private staticdeğişkenler o sınıfın örnekleri arasında pay verilerine kullanılabilir. private staticDeğişkenlere ClassName.memberveya gibi yapıları kullanarak erişemeyeceğimiz doğru olsa da ClassInstance.member, üye her zaman o sınıfın yöntemlerinden veya o sınıfın örneklerinden görülebilir. Yani aslında bu sınıfın örnekleri her zaman üyeye başvurabilir.

Özel bir statik sınıf değişkeninin kullanımı nedir?

Diyelim ki bir kütüphane kitabınız var Class. Her yeni Kitap oluşturduğunuzda, ona benzersiz bir kimlik atamak istersiniz. Bunun bir yolu sadece 0'dan başlamak ve kimlik numarasını arttırmaktır. Ancak, diğer tüm kitaplar son oluşturulan kimlik numarasını nasıl biliyor? Basit, statik bir değişken olarak kaydedin. Kullanıcıların her bir kitap için gerçek dahili kimlik numarasının olduğunu bilmeleri gerekir mi? Hayır. Bu bilgi özeldir.

public class Book {
    private static int numBooks = 0;
    private int id;
    public String name;

    Book(String name) {
        id = numBooks++;
        this.name = name;
    }
}

Bu konuyla ilgili bir örnektir, ancak eminim ki tüm sınıf örneklerinin herkesten özel olarak saklanması gereken ortak bilgilere erişmesini istediğiniz durumları kolayca düşünebilirsiniz. Ya da yapamasanız bile, işleri olabildiğince özel yapmak iyi bir programlama uygulamasıdır. Kitap kullanıcılarının onunla hiçbir şey yapmamalarına rağmen, bu numBooks alanını yanlışlıkla herkese açık yaptıysanız ne olur? Sonra birisi yeni bir Kitap oluşturmadan Kitap sayısını değiştirebilir.

Çok sinsi!

Değişken private static varName;bildirmek, değişken bildirmekten farklı private varName;mıdır?

Evet, ikisi de farklı. Ve birincisi denir class variableçünkü bunun için tek bir değer tutarken classdiğeri denir instance variableçünkü farklı için farklı bir değer tutabilir instances(Objects). Birincisi jvm'de sadece bir kez oluşturulur ve diğeri örnek başına bir kez oluşturulur, yani 10 örneğiniz varsa private varName;jvm'de 10 farklı olacaktır .

Değişkeni staticdiğer özel özellikler olarak bildirmek mi?

Evet, statik değişkenler normal örnek değişkenlerden farklı özellikler alır. Zaten az bahsetmiştim ve burada bazılarını görelim: class variables(statik olarak bildirilen örnek değişkenler) gibi sınıf adı kullanılarak doğrudan erişilebilir ClassName.varName. Ve bu sınıftaki herhangi bir nesneye, yalnızca örnek nesneler tarafından erişilen örnek değişkenlerin aksine değerine erişebilir ve değerini değiştirebilirsiniz. Sınıf değişkenleri statik yöntemlerde kullanılabilir.

private static variableJava'da a'nın kullanımı nedir ?

Mantıksal olarak, ilkinden daha fazla kontrol sağlayandan private static variablefarklı değildir public static variable. IMO, kelimenin tam anlamıyla yerine public static variablegöre private static variableyardımıyla public staticalıcı ve ayarlayıcı yöntemlerinin.

Yaygın olarak kullanılan alanlarından biri private static variable, Singletontüm dünyada o sınıfın yalnızca tek bir örneğine sahip olacağınız basit modelin uygulanmasıdır . Burada statictanımlayıcı, tek bir örneğin dış dünya tarafından erişilebilir olmasını sağlamak için çok önemli bir rol oynar (Tabii ki genel statik alıcı yöntemi de ana rolü oynar).

public class Singleton {
    private static Singleton singletonInstance = new Singleton();

    private Singleton(){}

    public static Singleton getInstance(){
        return Singleton.singletonInstance;
    }
}

Özel anahtar kelime sınıf içinde değişken erişim için kullanacak ve değişkeni statik yöntemle de erişebildiğimiz için statik tutacaktır ancak referans değişkeni statik yöntemle erişemez.

Başka bir bakış açısı:

1. Bir sınıf ve örneği çalışma zamanında iki farklı şeydir. Sınıf bilgisi, söz konusu sınıfın tüm örnekleri tarafından "paylaşılır".
2. Statik olmayan sınıf değişkenleri örneklere, statik değişken ise sınıfa aittir.
3. Bir örnek değişkenleri özel veya genel olabileceği gibi, statik değişkenler de özel veya genel olabilir.

Statik yöntemde bir değişken kullandığınızda, değişkenin örnek olarak da statik olması gerekir:

private static int a=0;  
public static void testMethod() {  
        a=1;  
}

Statik değişkenler, bir sınıfın tüm örnekleri için ortak olan değişkenlerdir .. bir örnek onu değiştirirse .. statik değişkenin değeri diğer tüm örnekler için güncellenir

Bazı insanlar için bunu birkaç farklı dilde görmeleri daha mantıklıdır, bu yüzden sayfamda bu değiştiricilerin bazılarını açıkladığım Java ve PHP'de bir örnek yazdım. Bunu yanlış düşünüyor olabilirsiniz.

Aşağıda bir anlam ifade etmiyorsa örneklerime bakmalısınız. Buraya gidin http://www.siteconsortium.com/h/D0000D.php

Sonuç olarak, tam olarak söylediği şey tam olarak olmasıdır. Özel olan statik bir üye değişkendir. Örneğin, bir Singleton nesnesi oluşturmak istiyorsanız neden SingletonExample.instance değişkenini herkese açık hale getirmek istersiniz. Sınıfı kullanan bir kişi yaptıysanız, değerin üzerine kolayca yazılabilir.

Hepsi bu kadar.

    genel sınıf SingletonExample {
      private static SingletonExample örneği = null;
      özel statik int değeri = 0;
      private SingletonExample () {
        ++ this.value;
      }
      public static SingletonExample getInstance () {
        if (örneğin! = null)
        dönüş örneği;
        senkronize edildi (SingletonExample.class) {
        instance = yeni SingletonExample ();
        dönüş örneği;
        }
      }
      herkese açık geçersiz printValue () {
        System.out.print (this.value);
      }

      public static void main (Dize [] args) {
        SingletonExample örneği = getInstance ();
        instance.printValue ();
        instance = getInstance ();
        instance.printValue ();
         }
    }

Sınıfınızda özel statik değişkenler kullanırsanız, sınıfınızdaki Statik İç sınıflar değişkenlerinize ulaşabilir. Bu, bağlam güvenliği için mükemmel bir şekilde iyidir.

Bir değişken genel statik olarak tanımlanırsa, herhangi bir sınıftan kendi sınıf adıyla erişilebilir.

Genellikle işlevler, yalnızca uygulayıcı sınıf adını çağırarak erişilebilen genel statik olarak tanımlanır.

Bunun çok iyi bir örneği sleep()Thread sınıfındaki yöntemdir

Thread.sleep(2500);

Bir değişken özel statik olarak tanımlanmışsa, yalnızca bu sınıf içinde erişilebilir, böylece sınıf adı gerekmez veya sınıf adını (size) kullanabilirsiniz. Özel değişken_adı ile özel statik var_name arasındaki fark, özel statik değişkenlere yalnızca sınıfın statik yöntemleriyle erişilebilmesidir, özel değişkenlere ise o sınıfın herhangi bir yöntemiyle erişilebilmektedir (statik yöntemler hariç)

Buna çok güzel bir örnek, değişkenin özel statik olarak bildirilmesini gerektiren veritabanı bağlantılarını veya sabitleri tanımlamaktır.

Diğer bir yaygın örnek

private static int numberOfCars=10;

public static int returnNumber(){

return numberOfCars;

}

Java için yeniyim, ancak statik değişkenleri kullanmanın bir yolu, birçok insanın yaptığı gibi, sınıfın örnek sayısını saymaktır. Örneğin:

public Class Company {
    private static int numCompanies;

    public static int getNumCompanies(){
        return numCompanies;
    }
}

Sonra sysout yapabilirsiniz:

Company.getNumCompanies();

Ayrıca, sınıfın her örneğinden (tam olarak anlamadığım) numCompanies'a erişebilirsiniz, ancak "statik bir şekilde" olmayacaktır. Bunun en iyi uygulama olup olmadığı hakkında hiçbir fikrim yok, ama bu bana mantıklı geliyor.

*) Bir değişken özel olarak bildirilirse, sınıf dışında görünmez. Buna veri gizleme adı verilir.

*) Bir değişken statik olarak bildirilirse, değişkenin değeri tüm örnekler için aynıdır ve bu değişkeni çağırmak için bir nesne oluşturmamıza gerek yoktur.

classname.variablename;

özel statik değişken de alt sınıfta paylaşılacaktır. Bir alt sınıfta değişiklik yaptıysanız ve diğer alt sınıf değiştirilen değeri alırsa, bu durumda beklediğiniz gibi olmayabilir.

public class PrivateStatic {

private static int var = 10;
public void setVar(int newVal) {
    var = newVal;
}

public int getVar() {
    return var;
}

public static void main(String... args) {
    PrivateStatic p1 = new Sub1();
    System.out.println(PrivateStatic.var);
    p1.setVar(200);

    PrivateStatic p2 = new Sub2();
    System.out.println(p2.getVar());
}
}


class Sub1 extends PrivateStatic {

}

class Sub2 extends PrivateStatic {
}

ThreadLocaldeğişkenler genellikle olarak uygulanır private static. Bu şekilde, sınıfa bağlı değildir ve her iş parçacığının kendi "ThreadLocal" nesnesine kendi başvurusu vardır.

Aşağıdaki örnekte, eyePersonB tarafından değiştirilirken legaynı kalır. Bunun nedeni, özel bir değişkenin yönteme bir kopyasını oluşturmasıdır , böylece orijinal değeri aynı kalır; özel statik değerin tüm paylaşılacak yöntemler için yalnızca bir kopyası varken , değerini düzenlemek orijinal değerini değiştirir.

public class test {
private static int eye=2;
private int leg=3;

public test (int eyes, int legs){
    eye = eyes;
    leg=leg;
}

public test (){
}

public void print(){
    System.out.println(eye);
    System.out.println(leg);
}

public static void main(String[] args){
    test PersonA = new test();      
    test PersonB = new test(14,8);
    PersonA.print();    
}

}

> 14 3