如果变量被声明为public static varName;，那么我可以从任何地方访问ClassName.varName。我也知道静态成员由类的所有实例共享，并且不会在每个实例中重新分配。
声明变量private static varName;与声明变量private varName;有什么不同？
在这两种情况下，它都不能作为ClassName.varName或ClassInstance.varName从任何其他类访问。
将变量声明为静态会给它带来其他特殊属性吗？
当然它可以作为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取决于你是否希望变量在课堂外可见。
在静态方法中使用变量时，变量也必须是静态的，例如：
private static int a=0;
public static void testMethod() {
a=1;
}
静态变量是那些类的所有实例共有的变量。如果一个实例改变了它，那么静态变量的值将为所有其他实例更新
对于某些人来说，如果他们用几种不同的语言看到它会更有意义，所以我用Java编写了一个例子，在我的页面上用PHP解释了一些这些修饰符。您可能会错误地考虑这个问题。
如果下面没有意义，你应该看看我的例子。去这里http://www.siteconsortium.com/h/D0000D.php
但最重要的是，它几乎就是它所说的。它是一个私有的静态成员变量。例如，如果要创建Singleton对象，为什么要将SingletonExample.instance变量设为public。如果你做了一个使用该类的人可以轻易覆盖该值。
这就是全部。
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();
}
}
如果在类中使用私有静态变量，则类中的静态内部类可以到达变量。这对于上下文安全性非常有用。
如果变量定义为公共静态，则可以通过其类名从任何类访问它。
通常将函数定义为public static，只需调用实现类名即可访问它。
一个非常好的例子是Thread类中的sleep()方法
Thread.sleep(2500);
如果变量被定义为私有静态，则只能在该类中访问它，因此不需要类名，或者您仍然可以使用类名（由您决定）。 private var_name和private static var_name之间的区别在于私有静态变量只能由类的静态方法访问，而私有变量可以由该类的任何方法访问（静态方法除外）
一个非常好的例子是在定义数据库连接或常量时需要将变量声明为私有静态。
另一个常见的例子是
private static int numberOfCars=10;
public static int returnNumber(){
return numberOfCars;
}
我是Java的新手，但是我使用静态变量的一种方式，就像我假设很多人一样，是计算类的实例数。例如。：
public Class Company {
private static int numCompanies;
public static int getNumCompanies(){
return numCompanies;
}
}
然后你可以sysout：
Company.getNumCompanies();
您还可以从类的每个实例（我不完全理解）访问numCompanies，但它不会以“静态方式”。我不知道这是不是最好的做法，但它对我来说是有意义的。
*）如果变量被声明为私有，那么它在类之外是不可见的。这被称为datahiding。
*）如果变量被声明为static，那么变量的值对于所有实例都是相同的，我们不需要创建一个对象来调用该变量。我们可以通过简单地调用该变量
classname.variablename;
私有静态变量也将在子类中共享。如果您在一个子类中更改而另一个子类将获得更改的值，在这种情况下，它可能不是您所期望的。
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 {
}
ThreadLocal变量通常实现为私有静态。通过这种方式，它们不会绑定到类，每个线程都有自己的“threadLocal”对象引用。
在下面的示例中，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
静态变量对于类的所有实例都具有单个值。
如果你要做的事情如下：
public class Person
{
private static int numberOfEyes;
private String name;
}
然后你想改变你的名字，这很好，我的名字保持不变。如果你想改变它以便你有17只眼睛，那么世界上每个人也会有17只眼睛。
私有静态变量的使用方式与私有实例变量的用法相同：它们存储的状态只能由同一个类中的代码访问。可访问性（私有/公共/等）和变量的实例/静态性质是完全正交的概念。
我会避免将静态变量视为在类的“所有实例”之间共享 - 这表明必须存在至少一个状态实例。否 - 静态变量与类型本身相关联，而不是与该类型的任何实例相关联。
因此，只要您想要某个与该类型相关联的状态而不是任何特定实例，并且您希望将该状态保持为私有（例如，允许通过属性进行受控访问），那么拥有私有静态变量是有意义的。
顺便说一句，我强烈建议您公开（甚至非私有）的唯一变量类型是常量 - 不可变类型的静态最终变量。为了分离API和实现（除其他事项外），其他所有内容都应该是私有的。
那么，private static变量可用于跨该类的实例共享数据。虽然你是正确的，我们不能使用像private static或ClassName.member这样的结构来访问ClassInstance.member变量，但是该成员将始终从该类或该类的实例的方法中可见。所以实际上该类的实例总是能够引用成员。
那么你是正确的公共静态变量是在不创建类的实例的情况下使用的，但私有静态变量则不是。它们与我使用私有静态变量的地方之间的主要区别在于您需要在静态函数中使用变量。对于静态函数，您只能使用静态变量，因此您将它们设为私有，以便不从其他类访问它们。这是我使用私有静态的唯一情况。
这是一个例子：
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;
}
}
声明变量
private static varName;与声明变量private varName;有什么不同？
是的，两者都不同。第一个被称为class variable，因为它为class保持单一值，而另一个被称为instance variable，因为它可以为不同的instances(Objects)保持不同的值。第一个在jvm中只创建一次，而另一个在每个实例创建一次，即如果你有10个实例，那么你将在jvm中有10个不同的private varName;。
将变量声明为
static会给它带来其他特殊属性吗？
是的，静态变量获得的内容与普通实例变量不同。我已经提到了一些，让我们在这里看到一些：class variables（声明为静态的实例变量）可以通过使用像ClassName.varName这样的类名直接访问。并且该类的任何对象都可以访问和修改其值，而不像实例变量仅由其各自的对象访问。类变量可以在静态方法中使用。
在Java中使用
private static variable有什么用？
从逻辑上讲，private static variable与public static variable没有什么不同，而第一个让你有更多的控制权。 IMO，你可以在public static variable getter和setter方法的帮助下用private static variable替换public static。
private static variable的一个广泛使用的领域是在简单的Singleton模式的实现中，你将在整个世界中只有该类的单个实例。这里static标识符起着至关重要的作用，使得单个实例可以被外界访问（当然公共静态getter方法也起主要作用）。
public class Singleton {
private static Singleton singletonInstance = new Singleton();
private Singleton(){}
public static Singleton getInstance(){
return Singleton.singletonInstance;
}
}
私有静态类变量的用途是什么？
假设你有一本图书馆课。每次创建新书时，都要为其分配唯一ID。一种方法是简单地从0开始并增加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用户不应该对它做任何事情，该怎么办？然后有人可以在不创建新书的情况下更改书籍数量。
非常偷偷摸摸！
私有关键字将用于类中的变量访问并保持静态，我们也可以在静态方法中访问变量，但引用变量无法在静态方法中访问。
另一个观点：