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

如果一个变量被声明为 public static varName;，那么我可以从任何地方以 ClassName.varName的形式访问它。我还注意到，静态成员由类的所有实例共享，不会在每个实例中重新分配。

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

在这两种情况下，它都不能作为 ClassName.varName或 ClassInstance.varName从任何其他类访问。

将变量声明为 static 会赋予它其他特殊属性吗？

382101 次浏览
小开
最佳答案

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

小开

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

如果你要做这样的东西:

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

然后你想改名字，没关系，我的名字不变。不管怎样，如果你想改变它，让你有17只眼睛，那么世界上的每个人都会有17只眼睛。

小开

可以使用 private static变量跨该类的实例共享数据。虽然我们不能使用像 ClassName.member或 ClassInstance.member这样的构造访问 private static变量，但是成员总是可以从该类的方法或该类的实例中看到，这是正确的。因此，该类的实例实际上总是能够引用 member。

小开

在静态方法中使用变量时，变量也必须是静态的 例如:

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

私有静态变量的用处与私有实例变量的用处相同: 它们存储的状态只能由同一类中的代码访问。可访问性(private/public/etc)和变量的实例/静态性质是完全正交的概念。

我会避免把静态变量看作是类的“所有实例”之间共享的——这意味着必须至少有 一实例才能存在状态。静态变量与类型本身关联，而不是与类型的 任何实例关联。

因此，任何时候你想要一些与类型相关联的状态，而不是任何特定的实例，并且你想要保持该状态的私有性(例如，可能允许通过属性进行受控访问) ，拥有一个私有的静态变量是有意义的。

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

小开

另一种观点:

  1. 类和它的实例在运行时是两件不同的事情。类信息由该类的所有实例“共享”。
  2. 非静态类变量属于实例，静态变量属于类。
  3. 就像实例变量可以是私有的或公有的，静态变量也可以是私有的或公有的。
小开

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

这里有一个例子:

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

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

假设你有一个图书馆图书课。每次创建新 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 用户不应该使用它做任何事情。然后有人可以改变书的数量，而不用创建一个新的书。

真狡猾！

小开

静态变量是那些在类的所有实例中通用的变量。.如果一个实例改变了它。.然后静态变量的值将更新为所有其他实例

小开

对于一些人来说，如果他们在几种不同的语言中看到它，这就更有意义了，所以我用 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();
}
}
小开

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

通常函数被定义为公共静态，只需调用实现类名即可访问。

一个很好的例子是 Thread 类中的 sleep()方法

Thread.sleep(2500);

如果一个变量被定义为 private static，那么它只能在这个类中被访问，所以不需要类名，或者你仍然可以使用类名(由你自己决定)。 Private var _ name 和 private static var _ name 的区别在于，私有静态变量只能通过类的静态方法访问，而私有变量可以通过该类的任何方法访问(静态方法除外)

一个很好的例子是在定义数据库连接或常量时，需要将变量声明为 private static。

另一个常见的例子是

private static int numberOfCars=10;


public static int returnNumber(){


return numberOfCars;


}
小开

private关键字将允许在类中使用变量访问，而 static意味着我们可以在静态方法中访问变量。

您可能需要这样做，因为在静态方法中无法访问非静态引用变量。

小开

我对 Java 是个新手，但是我使用静态变量的一种方法是计算类的数量，我想很多人都会这么做。例如:

public Class Company {
private static int numCompanies;


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

然后你可以系统分析:

Company.getNumCompanies();

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

小开

*)如果一个变量被声明为 private，那么它在 class.this 之外是不可见的。

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

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

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

小开

将变量声明为与 声明变量 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没有什么不同，而第一个 private static variable给了你更多的控制权。我的意思是，你可以字面上取代 public static variable的 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;
}
}
小开

在下面的示例中，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();
}

}

> 14 3

小开

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

小开

私有静态字段和私有静态方法可以在公共静态方法内部使用。它们有助于减少公共静态方法内部的过多逻辑。


提交答案