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

时间：2011-09-02 06:24:15

标签： java variables static private

如果变量声明为public static varName;，那么我可以从任何位置ClassName.varName访问它。我也知道静态成员由类的所有实例共享，并且不会在每个实例中重新分配。

将变量声明为private static varName;与声明变量private varName;有什么不同？

在这两种情况下，都无法从ClassName.varName或ClassInstance.varName访问任何其他类。

将变量声明为static是否会为其提供其他特殊属性？

19 个答案:

答案 0 :(得分：108)

当然它可以作为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取决于您是否希望变量在课堂外可见。

答案 1 :(得分：89)

静态变量对于类的所有实例都有一个值。

如果你要做类似的事情：

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

然后你想改变你的名字，这很好，我的名字保持不变。如果你想改变它以便你有17只眼睛，那么世界上每个人也会有17只眼睛。

答案 2 :(得分：43)

私有静态变量的用法与私有实例变量的用法相同：它们存储的状态只能由同一个类中的代码访问。可访问性（私有/公共/等）和变量的实例/静态性质完全是正交的概念。

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

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

顺便说一句，我强烈建议您公开（甚至非私有）的仅类型的变量是常量 - 不可变类型的静态最终变量。为了分离API和实现（以及其他内容），其他所有内容都应该是私有的。

答案 3 :(得分：8)

嗯，private static变量可用于跨该类的实例共享数据。虽然您是正确的，但我们无法使用private static或ClassName.member等构造访问ClassInstance.member变量，但该成员将始终从该类的方法或该类的实例中可见。所以实际上该类的实例总是能够引用成员。

答案 4 :(得分：8)

你是正确的公共静态变量是在不创建类的实例的情况下使用的，但私有静态变量却没有。它们与我使用私有静态变量的地方之间的主要区别在于您需要在静态函数中使用变量。对于静态函数，您只能使用静态变量，因此您将它们设为私有，以便不从其他类访问它们。这是我使用私有静态的唯一情况。

以下是一个例子：

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

答案 5 :(得分：6)

  

将变量声明为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;
    }
}

答案 6 :(得分：5)

私有静态类变量有什么用？

假设你有一本图书馆课。每次创建新书时，都要为其分配唯一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用户不应该对它做任何事情，该怎么办？然后有人可以在不创建新书的情况下更改书籍数量。

非常偷偷摸摸！

答案 7 :(得分：3)

私有关键字将用于类中的变量访问，并保持静态，我们也可以在静态方法中访问变量，但引用变量无法在静态方法中访问。

答案 8 :(得分：2)

另一个观点：

  1. 一个类及其实例在运行时是两个不同的东西。类信息由该类的所有实例“共享”。
  2. 非静态类变量属于实例，静态变量属于类。
  3. 就像实例变量可以是私有变量或公共变量一样，静态变量也可以是私有变量或公共变量。

答案 9 :(得分：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();
         }
    }

答案 10 :(得分：1)

如果在类中使用私有静态变量，则类中的静态内部类可以到达变量。这对于上下文安全性非常有用。

答案 11 :(得分：1)

静态变量是那些类的所有实例共有的变量。如果一个实例改变了它，那么静态变量的值将为所有其他实例更新

答案 12 :(得分：1)

在静态方法中使用变量时，变量也必须是静态的 举个例子：

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

答案 13 :(得分：0)

如果变量被定义为公共静态，则可以通过任何类的类名访问它。

通常将函数定义为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;

}

答案 14 :(得分：0)

我是Java的新手，但是我使用静态变量的一种方法，就像我假设很多人一样，是计算类的实例数。 e.g：

public Class Company {
    private static int numCompanies;

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

然后你可以sysout：

Company.getNumCompanies();

您还可以从类的每个实例（我不完全理解）访问numCompanies，但它不会以“静态方式”访问。我不知道这是不是最佳做法，但对我来说是有意义的。

答案 15 :(得分：0)

*）如果一个变量被声明为私有，那么它在类之外是不可见的。这被称为datahiding。

*）如果变量被声明为static，那么变量的值对于所有实例都是相同的，我们不需要创建一个对象来调用该变量。我们可以通过简单地调用该变量

classname.variablename;

答案 16 :(得分：0)

私有静态变量也将在子类中共享。如果您在一个子类中进行了更改，而另一个子类将获得更改的值，在这种情况下，它可能不是您所期望的。

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

答案 17 :(得分：0)

ThreadLocal变量通常实现为私有静态。 通过这种方式，它们不会绑定到类，每个线程都有自己的“threadLocal”对象引用。

答案 18 :(得分：-1)

在以下示例中，PersonB更改了eye，而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();    
}

}

  

＆GT;   14   3

相关问题
最新问题