【成员变量和局部变量】

• 成员变量 在类中定义，用来描述对象将要有什么

• 局部变量 在类的方法中定义，在方法中临时保存数据

• 同名变量不同
  “在同一个方法中，不允许有同名的局部变量”
  “在不同的方法中，可以有同名的局部变量”

• 成员变量和局部变量的区别
  1)作用域不同
  “局部变量的作用域仅限于定义它的方法”
  “成员变量的作用域在整个类内部都是可见的”
  2)初始值不同
  “成员变量有默认的初始值”
  “局部变量没有默认的初始值，必须自行设定初始值”
  3)存储位置不同
  “成员变量是在对象创建以后存在于堆中，对象回收时，成员变量消失”
  “局部变量是在方法被调用时存在于栈中，方法调执行结束，从栈中清除”
  4)生命周期不同
  “对象的创建而创建，对象回收时，成员变量消失”
  “随着方法的调用被创建，方法执行结束，从栈中清除”

public class Variable {
    
    /** * 成员变量 */
    public int count;
    public int x;
    public static int y;

    public void fun01() {
    
        int a = 10;
        System.out.println("fun01()中a的值 >>> " + a);
    }

    public void fun02() {
    
        int a = 20;
        System.out.println("fun02()中a的值 >>> " + a);
    }

    public void fun03() {
    
        int a = 30;
        int b;
        System.out.println("fun03()中a的值 >>> " + a);
        // The local variable b may not have been initialized
        // java: 可能尚未初始化变量b
        // 局部变量 如果被调用初始化
        // System.out.println("fun03()中b的值 >>> " + b);
    }

    public void fun04() {
    
        System.out.println("成员变量count的值 >>> " + count);
    }

    public void fun05() {
    
        System.out.println("成员变量count的值 >>> " + count++);
    }

    public void fun06() {
    
        System.out.println("成员变量count的值 >>> " + ++count);
    }

    public void fun07(){
    
        System.out.println("非静态成员变量x的值 >>> " + ++x);
        System.out.println("静态成员变量y的值 >>> " + ++y);
    }
}

public class VariableTest {
    
    @Test
    public void test01(){
    
        Variable variable = new Variable();
        // fun01()中a的值 >>> 10
        variable.fun01();
        // fun02()中a的值 >>> 20
        variable.fun02();
        // fun03()中a的值 >>> 30
        variable.fun03();
        // 成员变量count的值 >>> 0
        variable.fun04();
        // 成员变量count的值 >>> 0
        variable.fun05();
        // 成员变量count的值 >>> 2
        variable.fun06();
    }
    @Test
    public void test02(){
    
        Variable variable = new Variable();
        // 成员变量count的值 >>> 1
        variable.fun06();
        // 成员变量count的值 >>> 2
        variable.fun06();
    }

    @Test
    public void test03(){
    
        Variable variable01 = new Variable();
        Variable variable02 = new Variable();
        // 成员变量count的值 >>> 1
        variable01.fun06();
        // 成员变量count的值 >>> 2
        variable01.fun06();
        // 成员变量count的值 >>> 1
        variable02.fun06();
    }
    @Test
    //重点:可能不好理解，多运行几遍，试试Debug看看过程
    //注意：非静态成员变量只能在对象的内部共享数据
    // 静态成员变量可以在多个对象之间共享数据
    public void test04(){
    
        Variable variable01 = new Variable();
        Variable variable02 = new Variable();
        // 非静态成员变量x的值 >>> 1
        // 静态成员变量y的值 >>> 1
        variable01.fun07();
        // 非静态成员变量x的值 >>> 1
        // 静态成员变量y的值 >>> 2
        //为什么y的值输出是二呢
        //因为静态y的初始值在另外的区域进行赋值，并且可以进行多个对象赋值，刚刚01进行++y，等于1了，因此这次在调用的时候就是1++，因此是2
       
        variable02.fun07();
        // 下面的非静态x值为什么是2呢，因为同一个对象调用了两次
        // 非静态成员变量x的值 >>> 2
        // 静态成员变量y的值 >>> 3
        variable01.fun07();
        // 非静态成员变量x的值 >>> 2
        // 静态成员变量y的值 >>> 4
        variable02.fun07();
    }


}