3

静态/类变量在类型/类中定义，据说与定义它的类型/类相关联，并且独立于类型/类的实例。类型/类中只有一个静态/类变量，最适合用于类似常量的属性，其值在类的任何实例中都是通用的。静态/类变量的状态始终存在于类中，因此类中的任何时刻都只有一个变量，关键字 static 用于定义变量的这种性质。最佳实践中的静态/类变量将被初始化一次，并使用关键字 final 确保这一点。最终的静态变量将使用不可变集合初始化，如在 new String() 或 new Integer() 中；

现在我的问题是如何使用静态变量的值？而这个变量的用途是什么？例如，它是从包含它的类中复制它的值，还是对类中变量的显式引用？

例如

class GenericType {
    private final static String commonValue = new String("foobar");
} 
class AnotherGenericType {
    public static void main(String[] args) {
        System.out.println(GenericType.commonValue); //Displays foobar in the console.

    }
}
4

4 回答 4

5

有专门为存储static变量分配的空间。这在JLS, 8.3.1.1中指定，其中指出

如果一个字段被声明为静态的，那么无论最终创建多少个类的实例（可能为零），都只存在该字段的一个化身。静态字段，有时称为类变量，在类初始化时体现。

值得注意的是，这些变量在类被卸载之前不会被垃圾收集打开（这通常不会经常发生），这可能会导致意外的内存引用被持有。

访问静态成员可能被称为“静态访问”（我以前听说过它），但通常它没有自己的术语。

于 2012-07-25T18:21:51.007 回答
1

静态变量与类本身相关联，而不是与类的实例相关联。static当类在运行时加载时，任何用关键字标记的东西都会被初始化。这就是为什么你可以用类名来调用它们，以及为什么你可以在不创建对象的情况下使用它们。

JLS 指定使用静态变量被称为：using a static variable. 只是在开玩笑。

于 2012-07-25T18:21:19.160 回答
1

它只是一个参考。

在这种情况下，ascommonValue定义为final并且String是不可变的，您看不到它。但假设以下代码：

public class GenericType {
    public static Collection myCollection = new ArrayList();
}

public class Test {

    public static void main(String[] args) {
        // you are accessing the public static field
        GenericType.myCollection.add("first item");
        System.out.println(GenericType.myCollection);

        // now c holds a reference for the collection that is referred by myCollection field
        Collection c = GenericType.myCollection;
        GenericType.myCollection.add("second item");
        GenericType.myCollection = new ArrayList();

        // printing the object referred by c (the old reference hold by myCollection field)
        System.out.println(c);

        // and here the current reference of myCollection field
        System.out.println(GenericType.myCollection);
    }

}
于 2012-07-25T18:24:30.850 回答
0

正如@Francisco Spaeth 所指出的，JLS 很明确：实例之间只有一个静态值共享。
但是一个类可以用不同的类加载器加载到同一个程序中，这意味着每个类加载器可能有不同的静态值。举个例子：

package classloaders;

import java.lang.reflect.Field;
import java.net.URL;
import java.net.URLClassLoader;

class SampleClass{
    static public final long loadTime = System.nanoTime();
}

public class Main {

    public static void main(String[] args) throws Exception {

        URL url = new URL("file:///C:/workspaces/personal/JavaTest/bin/");
        ClassLoader cl1 = new URLClassLoader(new URL[]{url}, null);
        ClassLoader cl2 = new URLClassLoader(new URL[]{url}, null);

        Class<SampleClass> sampleClass = (Class<SampleClass>) cl1.loadClass("classloaders.SampleClass");
        Field field1 = sampleClass.getField("loadTime");
        field1.setAccessible(true);
        System.out.println(field1.get(null));

        Class<SampleClass> sampleClass2 = (Class<SampleClass>) cl2.loadClass("classloaders.SampleClass");
        Field field2 = sampleClass2.getField("loadTime");
        field2.setAccessible(true);
        System.out.println(field2.get(null));

    }

}

如果您运行此代码，您将类似于

193798032450350
193798062432257

所以你可以通过使用不同的类加载器在同一个类的同一个静态字段中看到两个不同的值。

但这是一个非常奇怪的案例......

于 2012-07-25T19:23:43.397 回答