在Java中使用私有静态variables是什么？
如果一个variables声明为public static varName; ，那么我可以从任何地方访问它作为ClassName.varName 。 我也知道，静态成员是由一个类的所有实例共享，并不是在每个实例重新分配。
声明一个variables为private static varName; 与声明一个variablesprivate varName; ？
在这两种情况下，都不能以ClassName.varNameforms访问，也不能以任何其他类的forms访问ClassInstance.varName 。
将静态variables声明为其他特殊属性吗？
当然，它可以作为ClassName.var_name来访问，但只能从定义类的内部访问 – 这是因为它是private 。
public static或private staticvariables通常用于常量。 例如，很多人不喜欢在代码中“硬编码”常量， 他们喜欢用一个有意义的名字来创build一个public static或者private staticvariables，并且在他们的代码中使用这个variables，这会使代码更具可读性。 （你也应该使这样的常量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取决于您是否希望variables在课堂外可见。
静态variables对于一个类的所有实例都有一个单一的值。
如果你要做出如下的事情：
public class Person { private static int numberOfEyes; private String name; }
然后你想改变你的名字，这很好，我的名字保持不变。 不过，如果你想改变这个angular度，让你有17只眼睛，那么世界上的每个人也将有17只眼睛。
私有静态variables的用法与私有实例variables很有用：它们存储只能由同一个类中的代码访问的状态。 可访问性（private / public / etc）和variables的实例/静态性质完全是正交的概念。
我会避免将静态variables看作是在类的“所有实例”之间共享的 – 这意味着至less有一个状态存在的实例。 否 – 静态variables与types本身相关联，而不是types的任何实例。
所以任何时候你想要一个与types相关的状态而不是任何特定的实例，并且你想保持这个状态是私有的（例如允许通过属性进行受控访问），那么有一个私有的静态variables是有意义的。
顺便说一下，我强烈build议您公开的（甚至非私有的）variables的唯一types是常量 – 不可变types的静态最终variables。 为了分离API和实现（除其他外），其他一切应该是私有的。
那么，可以使用private staticvariables来跨该类的实例共享数据。 虽然你是正确的，我们不能使用像ClassName.member或ClassInstance.member这样的结构访问private staticvariables，但是成员将始终可以从该类或该类的实例的方法中看到。 所以这个类的实例总是能够引用成员。
那么你是对的公共静态variables使用没有做一个类的实例，但私人静态variables不是。 它们之间的主要区别和我使用私有静态variables的地方是当你需要在一个静态函数中使用一个variables。 对于静态函数，你只能使用静态variables，所以你让它们是私有的，不能从其他类访问它们。 这是我使用私有静态的唯一情况。
这里是一个例子：
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; } }
什么是私人静态类variables的使用？
比方说，你有一个图书馆的书类。 每次创build新书时，都要为其分配一个唯一的ID。 一种方法是简单地从0开始，递增ID号码。 但是，所有其他书籍如何知道最后创build的ID号码？ 简单来说，把它保存为一个静态variables。 读者是否需要知道每本书的实际内部编号？ 不。那个信息是私人的。
public class Book { private static int numBooks = 0; private int id; public String name; Book(String name) { id = numBooks++; this.name = name; } }
这是一个人为的例子，但我相信你可以很容易地想到你希望所有的类实例都可以访问应该与其他人保持私有的公共信息的情况。 或者即使你做不到，编程也是很好的做法。 如果你不小心使numBooks字段公开，即使Book用户不应该做任何事情。 然后有人可以改变图书的数量，而无需创build新的图书。
非常偷偷摸摸！
声明一个variables为
private static varName;与声明一个variablesprivate varName;？
是的，两者不同。 而第一个被称为class variable因为它为class保存单一的值，而另一个被称为instance variable因为它可以为不同的instances(Objects)保持不同的值。 第一个是在jvm中只创build一次，另一个是每个实例创build一次，即如果你有10个实例，那么你将有10个不同的private varName; 在jvm。
将
staticvariables声明为其他特殊属性吗？
是的，静态variables比普通的实例variables有一些不同的属性。 我已经提到了几个，让我们看看这里： class variables （声明为静态的实例variables）可以直接通过使用类名如ClassName.varName 。 而且这个类的任何对象都可以访问和修改它的值，而实例variables只能被其各自的对象访问。 类variables可以在静态方法中使用。
在Java中使用
private static variable是什么？
从逻辑上讲， private static variable与public static variable没有区别，相反，第一个public static variable赋予更多的控制权。 国际海事组织，你可以从字面上利用public static getter和setter方法，通过private static variablereplacepublic 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; } }
另一个angular度：
- 一个类及其实例在运行时是两个不同的东西。 类信息由该类的所有实例“共享”。
- 非静态类variables属于实例，静态variables属于类。
- 就像一个实例variables可以是私有的或公共的，静态variables也可以是私有的或公共的。
private关键字将用于类内的variables访问，并保持静态，我们也可以在静态方法中访问variables，但引用variables不能以静态方法访问。
当你在一个静态方法中使用一个variables时，variables也必须是静态的，例如：
private static int a=0; public static void testMethod() { a=1; }
静态variables是那些对一个类的所有实例都是通用的variables..如果有一个实例改变了它，那么静态variables的值将被更新为所有其他实例
对于一些人来说，如果他们用几种不同的语言来看，这样做会更有意义，所以我用Java写了一个例子，在我的页面上用了PHP来解释一些修饰符。 你可能会错误地考虑这个问题。
如果下面没有意义，你应该看看我的例子。 去这里http://www.siteconsortium.com/h/D0000D.php
但底线是，它几乎是它所说的。 这是一个静态成员variables，是私人的。 例如，如果你想创build一个Singleton对象，你为什么要公开SingletonExample.instancevariables。 如果你做了一个使用这个class的人，可以很容易地重写这个值。
就是这样。
公共类SingletonExample {
private static SingletonExample instance = null;
private static int value = 0;
私人SingletonExample（）{
++ THIS.VALUE;
}
公共静态SingletonExample getInstance（）{
如果（例如！= NULL）
返回实例;
同步（SingletonExample.class）{
instance = new SingletonExample（）;
返回实例;
}
}
public void printValue（）{
System.out.print（this.value）;
}
public static void main（String [] args）{
SingletonExample instance = getInstance（）;
instance.printValue（）;
instance = getInstance（）;
instance.printValue（）;
}
}
如果您在类中使用私有静态variables，则类中的静态内部类可以访问您的variables。 这对于上下文安全来说是非常好的。
如果一个variables被定义为公共静态，它可以通过任何类的类名来访问。
通常函数被定义为公共静态，只需调用实现类名即可访问。
Thread类中的sleep()方法就是一个很好的例子
Thread.sleep(2500);
如果一个variables被定义为私有静态，它只能在该类中被访问，所以不需要类名，或者仍然可以使用类名（至此）。 private var_name和private static var_name的不同之处在于私有静态variables只能被类的静态方法访问，而私有variables可以被该类的任何方法访问（静态方法除外）
定义数据库连接或常量需要将variables声明为私有静态的一个很好的例子。
另一个常见的例子是
private static int numberOfCars=10; public static int returnNumber(){ return numberOfCars; }
我是Java的新手，但是我使用静态variables的一种方法就是计算类的实例数。 例如：
public Class Company { private static int numCompanies; public static int getNumCompanies(){ return numCompanies; } }
那么你可以sysout：
Company.getNumCompanies();
你也可以从类的每个实例（我不完全理解）访问numCompanies，但它不会以“静态方式”。 我不知道这是否是最佳做法，但这对我来说是有道理的。
*）如果一个variables被声明为私有的，那么它在类之外是不可见的。这个被称为数据隐藏。
*）如果一个variables声明为static，那么variables的值对于所有的实例是相同的，我们不需要创build一个对象来调用这个variables。我们可以简单地调用这个variables
classname.variablename;
私有静态variables也将在子类中共享。 如果你改变了一个子类，另一个子类将得到改变的值，在这种情况下，它可能不是你所期望的。
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 { }
ThreadLocalvariables通常被实现为私有静态。 这样，它们不被绑定到类，每个线程都有自己的“threadLocal”对象的引用。
在下面的例子中， eye被PersonB改变，而leg保持不变。 这是因为一个私有variables将自己的一个副本复制到方法中，所以它的原始值保持不变; 而私有静态值只有一个副本供所有的方法共享，所以编辑它的值会改变它的原始值。
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
