Java中私有静态变量的用途是什么？

如果变量声明为

public static varName

，然后我可以从任何地方以

ClassName.varName

的形式访问它。我还知道静态成员由类的所有实例共享，并且不会在每个实例中重新分配

将变量声明为

private static varName声明变量的任何不同
私有变量名

在这两种情况下，都不能从任何其他类以
ClassName.varName
或
ClassInstance.varName
的形式访问它

将变量声明为静态会给它带来其他特殊属性吗？
当然它可以作为
ClassName.var\u 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 class Person
{
    private static int numberOfEyes;
    private String name;
}

然后你想改变你的名字，没关系，我的名字不变。然而，如果你想改变它，使你有17只眼睛，那么世界上的每个人都会有17只眼睛。
那么，
私有静态变量可以用于在该类的实例之间共享数据。虽然您认为我们不能使用诸如
ClassName.member
或
ClassInstance.member
之类的构造访问
private static
变量是正确的，但该成员将始终从该类的方法或该类的实例中可见。因此，实际上，该类的实例将始终能够引用成员。
在静态方法中使用变量时，变量也必须是静态的
例如：

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

私有静态变量的用途与私有实例变量的用途相同：它们存储仅由同一类中的代码访问的状态。可访问性（private/public/etc）和变量的实例/静态性质是完全正交的概念

我会避免将静态变量视为在类的“所有实例”之间共享——这意味着状态必须至少存在一个实例。否-静态变量与类型本身关联，而不是与该类型的任何实例关联

因此，每当您想要与类型关联的某个状态而不是任何特定实例，并且希望将该状态保持为私有状态（例如，可能允许通过属性进行受控访问）时，使用私有静态变量是有意义的

另一方面，我强烈建议您公开（甚至非私有）的变量的唯一类型是常量——不可变类型的静态最终变量。为了分离API和实现（除其他外），其他一切都应该是私有的。
另一个角度：

类及其实例在运行时是两种不同的东西。类信息由该类的所有实例“共享”
非静态类变量属于实例，静态变量属于类
就像实例变量可以是私有的或公共的一样，静态变量也可以是私有的或公共的
您是对的，使用公共静态变量时没有创建类的实例，但使用私有静态变量时没有。它们与我使用私有静态变量的地方的主要区别在于，何时需要在静态函数中使用变量。对于静态函数，您只能使用静态变量，因此您可以将它们设置为私有，以避免从其他类访问它们。这是我使用私有静态的唯一情况

以下是一个例子：

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

私有静态类变量的用途是什么

假设你有一门图书馆图书课。每次创建新书时，您都希望为其分配一个唯一的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字段公之于众，即使书籍用户不应该对它做任何事情，那该怎么办。然后，有人可以在不创建新书的情况下更改书籍的数量

非常狡猾
 静态变量是一个类的所有实例所共有的变量。如果一个实例改变了它。。然后，所有其他实例的静态变量值都会被更新
对于一些人来说，如果他们用两种不同的语言看到它，这会更有意义，所以我在页面上用Java和PHP编写了一个示例，解释了其中的一些修饰符。你可能想的不对

如果下面的例子没有意义，你应该看看我的例子。到这里来

但底线是，它几乎与它所说的一模一样。它是一个私有的静态成员变量。例如，如果要创建Singleton对象，为什么要将SingletonExample.in
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();
         }
    }
Thread.sleep(2500);

private static int numberOfCars=10;

public static int returnNumber(){

return numberOfCars;

}

public Class Company {
    private static int numCompanies;

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

Company.getNumCompanies();

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

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

    private Singleton(){}

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

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