Java中私有靜態變量的用途是什么？

Question

如果一個變量被聲明為public static varName; ，然后我可以從任何地方訪問它作為ClassName.varName 。 我也知道靜態成員由類的所有實例共享，並且不會在每個實例中重新分配。

將變量聲明為private static varName; 與聲明變量private varName;任何不同private varName; ?

在這兩種情況下，它都不能作為ClassName.varName或作為ClassInstance.varName從任何其他類訪問。

將變量聲明為靜態是否會給它其他特殊屬性？

Answer 1

當然，它可以作為ClassName.var_name訪問，但只能從定義它的類內部訪問 - 那是因為它被定義為private 。

public static或private static變量通常用於常量。 例如，許多人不喜歡在他們的代碼中“硬編碼”常量； 他們喜歡使用有意義的名稱創建一個public static或private static變量，並在他們的代碼中使用它，這應該使代碼更具可讀性。 （您還應該將此類常量設為final ）。

例如：

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

        // ...
    }
}

將其設為public還是private取決於您是否希望變量在類外可見。

Answer 2

靜態變量對於類的所有實例都有一個值。

如果你要做這樣的事情：

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

然后你想改名，沒關系，我的名字保持不變。 然而，如果你想改變它，讓你有 17 只眼睛，那么世界上每個人也會有 17 只眼睛。

Answer 3

私有靜態變量的用處與私有實例變量的用處相同：它們存儲只能由同一類中的代碼訪問的狀態。 變量的可訪問性（私有/公共/等）和實例/靜態性質是完全正交的概念。

我會避免將靜態變量視為在類的“所有實例”之間共享 - 這表明必須至少有一個實例才能存在狀態。 否 - 靜態變量與類型本身相關聯，而不是與該類型的任何實例相關聯。

因此，任何時候您想要某個與類型相關聯的狀態而不是任何特定實例，並且您希望保持該狀態私有（例如，可能允許通過屬性進行受控訪問），擁有一個私有靜態變量是有意義的。

順便說一句，我強烈建議您公開（甚至非私有）的唯一變量類型是常量 - 不可變類型的靜態最終變量。 為了分離 API 和實現（除其他外），其他一切都應該是私有的。

Answer 4

好吧，您是對的，公共靜態變量在不創建類的實例的情況下使用，但私有靜態變量不是。 它們與我使用私有靜態變量的主要區別在於何時需要在靜態函數中使用變量。 對於靜態函數，您只能使用靜態變量，因此您將它們設為私有以防止從其他類訪問它們。 這是我使用私有靜態的唯一情況。

下面是一個例子：

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

Answer 5

好吧， private static變量可用於在該類的實例之間共享數據。 雖然您是正確的，我們無法使用ClassName.member或ClassInstance.member類的構造訪問private static變量，但該成員將始終從該類的方法或該類的實例中可見。 因此，實際上該類的實例將始終能夠引用成員。

Answer 6

將變量聲明為private static varName; 與聲明變量private varName;任何不同private varName; ?

是的，兩者是不同的。 和第一個被調用class variable ，因為它適用於該單值class而另一個被稱為instance variable ，因為它可以保持不同的不同的值instances(Objects) 。 第一個在 jvm 中只創建一次，另一個每個實例創建一次，即如果你有 10 個實例，那么你將有 10 個不同的private varName; 在 jvm 中。

將變量聲明為static是否會給它其他特殊屬性？

是的，靜態變量與普通實例變量有一些不同的屬性。 我已經提到了一些，讓我們在這里看看： class variables （聲明為靜態的實例變量）可以通過使用類名直接訪問，如ClassName.varName 。 並且該類的任何對象都可以訪問和修改其值，而實例變量只能由其各自的對象訪問。 類變量可以在靜態方法中使用。

Java中private static variable的用途是什么？

從邏輯上講， private static variable與public static variable沒有什么不同，第一個給你更多的控制權。 IMO，您可以在public static getter 和 setter 方法的幫助下用private static variable替換public static variable 。

private static variable一個廣泛使用的領域是實現簡單的Singleton模式，在這種模式下，全世界只有該類的單個實例。 這里static標識符起着至關重要的作用，使外部世界可以訪問單個實例（當然公共靜態 getter 方法也起着主要作用）。

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

    private Singleton(){}

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

Answer 7

私有靜態類變量有什么用？

假設您有一個圖書館書籍類。 每次創建新 Book 時，您都希望為其分配一個唯一的 id。 一種方法是簡單地從 0 開始並遞增 id 號。 但是，所有其他書籍如何知道最后創建的 ID 號？ 很簡單，把它保存為一個靜態變量。 讀者是否需要知道每本書的實際內部 ID 號？ 不，該信息是私密的。

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

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

這是一個人為的例子，但我相信您很容易想到這樣的情況，您希望所有類實例都可以訪問應該對其他人保密的公共信息。 或者，即使您不能，將事情盡可能保密也是一種很好的編程習慣。 如果您不小心將 numBooks 字段設為公開，即使 Book 用戶不應該對它做任何事情，該怎么辦。 然后有人可以在不創建新書的情況下更改書的數量。

非常狡猾！

Answer 8

private關鍵字將允許在類中使用變量訪問，而static意味着我們可以在靜態方法中訪問變量。

您可能需要這樣做，因為在靜態方法中無法訪問非靜態引用變量。

Answer 9

另一個觀點：

1. 一個類和它的實例在運行時是兩個不同的東西。 類信息由該類的所有實例“共享”。
2. 非靜態類變量屬於實例，靜態變量屬於類。
3. 就像實例變量可以是私有的或公共的一樣，靜態變量也可以是私有的或公共的。

Answer 10

靜態變量是那些對類的所有實例通用的變量..如果一個實例更改了它..那么靜態變量的值將為所有其他實例更新

Answer 11

對於某些人來說，如果他們在幾種不同的語言中看到它會更有意義，所以我在我的頁面上用 Java 和 PHP 編寫了一個示例，其中我解釋了其中的一些修飾符。 您可能會錯誤地考慮這一點。

如果下面沒有意義，你應該看看我的例子。 去這里http://www.siteconsortium.com/h/D0000D.php

但最重要的是，它幾乎就是它所說的那樣。 它是一個私有的靜態成員變量。 例如，如果您想創建一個 Singleton 對象，為什么要公開 SingletonExample.instance 變量。 如果您這樣做，使用該類的人很容易覆蓋該值。

這就是全部。

public class SingletonExample {
      private static SingletonExample instance = null;
      private static int value = 0;
      private SingletonExample() {
        ++this.value;
      }
      public static SingletonExample getInstance() {
        if(instance!=null)
        return instance;
        synchronized(SingletonExample.class) {
        instance = new SingletonExample();
        return instance;
        }
      }
      public void printValue() {
        System.out.print( this.value );
      }

      public static void main(String [] args) {
        SingletonExample instance = getInstance();
        instance.printValue();
        instance = getInstance();
        instance.printValue();
         }
    }

Answer 12

如果您在類中使用私有靜態變量，則類中的靜態內部類可以訪問您的變量。 這對上下文安全非常有用。

Answer 13

在靜態方法中使用變量時，變量也必須是靜態的，例如：

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

Answer 14

如果一個變量被定義為 public static 它可以通過它的類名從任何類訪問。

通常函數被定義為公共靜態，只需調用實現類名即可訪問。

一個很好的例子是 Thread 類中的sleep()方法

Thread.sleep(2500);

如果變量定義為私有靜態變量，則只能在該類中訪問它，因此不需要類名，或者您仍然可以使用類名（由您決定）。 私有變量名和私有靜態變量名的區別在於私有靜態變量只能被類的靜態方法訪問，而私有變量可以被該類的任何方法訪問（靜態方法除外）

一個很好的例子是在定義需要將變量聲明為 private static 的數據庫連接或常量時。

另一個常見的例子是

private static int numberOfCars=10;

public static int returnNumber(){

return numberOfCars;

}

Answer 15

我是 Java 新手，但是我使用靜態變量的一種方法，正如我假設很多人所做的那樣，是計算類的實例數。 例如：

public Class Company {
    private static int numCompanies;

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

然后你可以系統輸出：

Company.getNumCompanies();

您還可以從類的每個實例（我不完全理解）訪問 numCompanies，但它不會以“靜態方式”進行。 我不知道這是否是最佳實踐，但對我來說很有意義。

Answer 16

*)如果一個變量被聲明為私有，那么它在類之外是不可見的。這被稱為數據隱藏。

*)如果一個變量被聲明為靜態，那么變量的值對於所有實例都是相同的，我們不需要創建一個對象來調用該變量。我們可以簡單地調用該變量

類名。變量名；

Answer 17

私有靜態變量也將在子類中共享。 如果您在一個子類中進行了更改，而另一個子類將獲得更改后的值，在這種情況下，它可能不是您所期望的。

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

Answer 18

ThreadLocal變量通常實現為private static 。 這樣，它們就不會綁定到類，並且每個線程都有對自己的“ThreadLocal”對象的引用。

Answer 19

在以下示例中， eye是由PersonB變化，而leg保持不變。 這是因為私有變量將自身復制到方法中，因此其原始值保持不變； 而私有靜態值只有一個副本供所有方法共享，因此編輯其值將更改其原始值。

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