静态方法(实际上所有方法)以及静态变量都存储在PermGen部分，因为它们是反射数据的一部分(类相关数据，而不是与实例相关的)。

需要澄清的最新情况:

注意，只有变量及其技术值(原语或引用)存储在PermGen空间中。

如果静态变量是对象的引用，则该对象本身存储在堆的正常部分(年轻/旧代或幸存者空间)。这些对象(除非它们是类等内部对象)是不存储在PermGen空间。

例子：static int i = 1; //the value 1 is stored in the PermGen sectionstatic Object o = new SomeObject(); //the reference(pointer/memory address) is stored in the PermGen section, the object itself is not.

一个关于垃圾收集的词：

做不倚靠finalize()因为它不一定会跑。这完全取决于JVM何时运行垃圾收集器和收集什么，即使一个对象符合垃圾收集的条件。

当然，您可以将静态变量设置为NULL，从而删除对堆上对象的引用，但这并不意味着垃圾回收器将要收集它(即使没有更多的参考资料)。

另外finalize()只运行一次，因此您必须确保它不会引发异常或以其他方式阻止对象被收集。如果您通过某些异常停止了终结，finalize()不会再次在同一个对象上调用。

最后注意事项代码、运行时数据等的存储方式取决于所使用的JVM，即HotSpot可能与JRockit不同，甚至在相同JVM的不同版本之间也可能有所不同。上面的内容是基于HotsforJava 5和6的(它们基本上是相同的)，因为在回答时，我想说大多数人都使用这些JVM。由于Java 8时内存模型发生了重大变化，上述语句可能不适用于Java 8 HotSpot-而且我没有检查Java 7 HotSpot的更改，所以我猜以上对于那个版本仍然是正确的，但我在这里不确定。

展开全部

个人的总结

1 静态变量e69da5e6ba9062616964757a686964616f31333337616564只有一份被类的所有实例共享

2 静态变量的声明在编译时已经明确了内存的位置

3 延迟初始化是改变静态变量的值

引用

Java静态变量的初始化(static块的本质)

在网上看到了下面的一段代码：

1. public class Test {

2. static {

3. _i = 20;

4. }

5. public static int _i = 10;

6.

7. public static void main(String[] args) {

8. System.out.println(_i);

9. }

10. }

public class Test { static { _i = 20; } public static int _i = 10; public static void main(String[] args) { System.out.println(_i); } }

上述代码会打印出什么结果来呢？10还是20？本文将以此代码为引子，着重讨论一下静态变量的初始化问题。 楼主可以找组织先记下175再来记下161最后填写984就会出现扣裙问题1：静态变量如何初始化

Java类中可以定义一个static块，用于静态变量的初始化。如：

1. public class Test {

2. public static int _i;

3. static {

4. _i = 10;

5. }

6. }

public class Test { public static int _i; static { _i = 10; } }

当然最常用的初始化静态变量的操作是在声明变量时直接进行赋值操作。如：

1. public class Test {

2. public static int _i = 10;

3. }

public class Test { public static int _i = 10; }

那么上述两例在本质上有什么区别吗？回答是没有区别。两例代码编译之后的字节码完全一致，通过 “javap -c”查看到的字节码如下：

public class Test extends java.lang.Object{

public static int _i;

public Test();

Code:

0: aload_0

1: invokespecial #1; //Method java/lang/Object."":()V

4: return

static {};

Code:

0: bipush 10

2: putstatic #2; //Field _i:I

5: return

}

通过字节码还可以看出，当类的定义中不含有static块时，编译器会为该类提供一个默认的static块。当然这是在含有静态变量初始化操作的前 提下。如果静态变量没有初始化操作，则编译器不会为之提供默认的static块。如：

1. public class Test {

2. public static int _i;

3. }

public class Test { public static int _i; }

其字节码的表现形式为：

public class Test extends java.lang.Object{

public static int _i;

public Test();

Code:

0: aload_0

1: invokespecial #1; //Method java/lang/Object."":()V

4: return

}

由于静态变量是通过赋值操作进行初始化的，因此可以通过静态函数返回值的方式为其初始化。如：

1. public class Test {

2. public static int _i = init();

3.

4. private static int init() {

5. return 10;

6. }

7. }

public class Test { public static int _i = init(); private static int init() { return 10; } }

其本质与下面的代码相同：

1. public class Test {

2. public static int _i;

3. static {

4. _i = init();

5. }

6.

7. private static int init() {

8. return 10;

9. }

10. }

public class Test { public static int _i; static { _i = init(); } private static int init() { return 10; } }

问题2：JDK如何处理static块

类定义中可以存在多个static块吗？回答是可以。如：

1. public class Test {

2. public static int _i;

3. static {

4. _i = 10;

5. }

6.

7. public static void main(String[] args) {

8. }

9.

10. static {

11. _i = 20;

12. }

13. }

public class Test { public static int _i; static { _i = 10; } public static void main(String[] args) { } static { _i = 20; } }

此类编译之后的字节码为：

public class Test extends java.lang.Object{

public static int _i;

public Test();

Code:

0: aload_0

1: invokespecial #1; //Method java/lang/Object."":()V

4: return

public static void main(java.lang.String[]);

Code:

0: return

static {};

Code:

0: bipush 10

2: putstatic #2; //Field _i:I

5: bipush 20

7: putstatic #2; //Field _i:I

10: return

}

观察static{}部分可以看出，上例的代码与下面的代码效果一致：

1. public class Test {

2. public static int _i;

3.

4. public static void main(String[] args) {

5. }

6.

7. static {

8. _i = 10;

9. _i = 20;

10. }

11. }

public class Test { public static int _i; public static void main(String[] args) { } static { _i = 10; _i = 20; } }

此例可以证明，不仅类定义中可以有多个static块，而且在编译时编译器会将多个static块按照代码的前后位置重新组合成一个static 块。

问题3：如何看待静态变量的声明

静态变量存放在常量池之中。如何证明呢？如：

1. public class Test {

2. public static int _i = 10;

3. }

public class Test { public static int _i = 10; }

使用“javap -c -verbose”查看其字节码的内容如下：

public class Test extends java.lang.Object

SourceFile: "Test.java"

minor version: 0

major version: 49

Constant pool:

const #1 = Method #4.#14; // java/lang/Object."":()V

const #2 = Field #3.#15; // Test._i:I

const #3 = class #16; // Test

const #4 = class #17; // java/lang/Object

const #5 = Asciz _i;

const #6 = Asciz I;

const #7 = Asciz ;

const #8 = Asciz ()V;

const #9 = Asciz Code;

const #10 = Asciz LineNumberTable;

const #11 = Asciz ;

const #12 = Asciz SourceFile;

const #13 = Asciz Test.java;

const #14 = NameAndType #7:#8;// "":()V

const #15 = NameAndType #5:#6;// _i:I

const #16 = Asciz Test;

const #17 = Asciz java/lang/Object;

{

public static int _i;

public Test();

Code:

Stack=1, Locals=1, Args_size=1

0: aload_0

1: invokespecial #1; //Method java/lang/Object."":()V

4: return

LineNumberTable:

line 2: 0

static {};

Code:

Stack=1, Locals=0, Args_size=0

0: bipush 10

2: putstatic #2; //Field _i:I

5: return

LineNumberTable:

line 3: 0

}

我们看到，常量池中const #2指向的就是Test._i，也就是静态变量。静态变量被保存到常量池中的工作原理这里不深入讨论。在此需要注意的是：

* 静态变量的声明与初始化是两个不同的操作；

* 静态变量的声明在编译时已经明确了内存的位置。

如：

1. public class Test {

2. public static int _i = 10;

3. }

public class Test { public static int _i = 10; }

上述代码的本质可以视为：

1. public class Test {

2. // 静态变量的声明

3. public static int _i;

4.

5. // 静态变量的初始化

6. static {

7. _i = 10;

8. }

9. }

public class Test { // 静态变量的声明 public static int _i; // 静态变量的初始化 static { _i = 10; } }

由于静态变量的声明在编译时已经明确，所以静态变量的声明与初始化在编码顺序上可以颠倒。也就是说可以先编写初始化的代码，再编写声明代码。如：

1. public class Test {

2. // 静态变量的初始化

3. static {

4. _i = 10;

5. }

6.

7. // 静态变量的声明

8. public static int _i;

9. }

public class Test { // 静态变量的初始化 static { _i = 10; } // 静态变量的声明 public static int _i; }

对初始问题的解答

解答了上述三个问题，让我们再来看看开篇提到的问题。代码如下：

1. public class Test {

2. static {

3. _i = 20;

4. }

5. public static int _i = 10;

6.

7. public static void main(String[] args) {

8. System.out.println(_i);

9. }

10. }

public class Test { static { _i = 20; } public static int _i = 10; public static void main(String[] args) { System.out.println(_i); } }

其本质可以用下面的代码表示：

1. public class Test {

2. static {

3. _i = 20;

4. }

5. public static int _i;

6. static {

7. _i = 10;

8. }

9.

10. public static void main(String[] args) {

11. System.out.println(_i);

12. }

13. }

public class Test { static { _i = 20; } public static int _i; static { _i = 10; } public static void main(String[] args) { System.out.println(_i); } }

再简化一下，可以表示为：

1. public class Test {

2. public static int _i;

3.

4. static {

5. _i = 20;

6. _i = 10;

7. }

8.

9. public static void main(String[] args) {

10. System.out.println(_i);

11. }

12. }

public class Test { public static int _i; static { _i = 20; _i = 10; } public static void main(String[] args) { System.out.println(_i); } }

至此，代码已经明确告诉我们打印结果是什么了！

已赞过

已踩过<

你对这个回答的评价是？

评论

收起