1. package Testpackage;
   
2. 
   
3. public class Test {
   
4.         static int n;
   
5.         int z;
   
6.         public void getValue() {
   
7.                 int i = 0;
   
8.                 i = i + 1;
   
9.                 n = n + 2;
   
10.                 z = z + 3;
    
11.                
    
12.                 System.out.println("i=" + i);
    
13.                 System.out.println("n=" + n);
    
14.                 System.out.println("z=" + z);
    
15.         }
    
16. 
    
17.         public static void main(String args[]) {
    
18.                 Test t = new Test();
    
19.                 t.getValue();
    
20.                 t.n = 1;
    
21.                 t.z = 1;
    
22.                 t.getValue();
    
23.                 t=null;
    
24.                 t = new Test();
    
25.                 t.getValue();
    
26.         }
    
27. }

复制代码

输出结果：

1. i=1
   
2. n=2
   
3. z=3
   
4. i=1
   
5. n=3
   
6. z=4
   
7. i=1
   
8. n=5
   
9. z=3
   

复制代码

既然这样的话，static修饰的n的生命周期就和程序存在的时间一样长？类下面的z变量是和类的生命周期一样长？方法下面的i和方法声明周期一样长？
= =应该是这样的。

那不叫类的z变量，是类的对象的成员变量z。关于生命周期，static n是程序加载Test类（即字节码）就有，在内存的方法区中，知道程序结束。int z是new出对象就有（在堆内存中），直到对象失去引用，被垃圾回收器回收后才消失。int n是方法调用时就有，但是是在栈内存中，方法执行结束，就失去引用，被垃圾回收器回收后才消失。

坏米饭 发表于 2014-4-15 17:57
那不叫类的z变量，是类的对象的成员变量z。关于生命周期，static n是程序加载Test类（即字节码）就有，在内 ...

学习了。再问一下。。。那垃圾回收器什么时候回收呢。。是用完了马上回收还是。。？

Kelvinhu 发表于 2014-4-15 18:05
学习了。再问一下。。。那垃圾回收器什么时候回收呢。。是用完了马上回收还是。。？ ...

看视频也是只听说垃圾回收器会回收，但是什么时候回收不知道。应该不是马上回收的。

我总结的静态的成员变量和非静态的成员变量区别

1、在内存中的位置不同：

        静态变量在方法区的静态区中

        非静态变量在堆中的对象所属的区域中

2、进入内存的时间不同：

        静态变量在类加载的时候就随着类一起被加载到静态区中

        非静态的变量在创建对象后，随着对象的出现而在堆中出现

3、所属不同：

        静态变量所属于类，即类的变量

     非静态变量所属对象，即对象的变量

自己先查一下资料。