JAVA面向对象（二）

一.成员变量与局部变量以及二者之间的区别 成员变量 成员变量：在类中定义，用来描述对象将要有什么 局部变量 局部变量：在类的方法中定义，在方法中临时保存数据 成员变量和局部变量的区别 a)作用域不同
     -局部变量的作用域仅限于定义它的方法
     -成员变量的作用域在整个类内部都是可见的
b)初始值不同
     -成员变量有默认的初始值
     -局部变量没有默认的初始值，必须自行设定初始值
c)存储位置不同
     -成员变量是在对象创建以后存在于堆中，对象回收时，成员变量消失
     -局部变量是在方法被调用时存在于栈中，方法调用执行结束，从栈中清除
d)生命周期不同
     -对象的创建而创建，对象回收时，成员变量消失
     -随着方法的调用被创建，方法执行结束，从栈中清除
e)同名变量不同
     -在同一个方法中，不允许有同名的局部变量
     -在不同的方法中，可以有同名的局部变量 二.实例

首先创建一个Variable类，在方法之中，类之内，声明三个数据类型为int的变量count,

x未用静态修饰符修饰而y用静态修饰符修饰，用于测试包中体现调用成员变量时的区别

package com.lzy.bean;


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);
    }
}

然后再在  测试包(VariableTest)   里调用一下我们创建好的Variable类里的方法,

注意：调用成员变量和局部变量的区别，以及调用成员变量和成员变量之间的区别。

package com.lzy.bean;

import org.junit.jupiter.api.Test;


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
    public void test04(){
        Variable variable01 = new Variable();
        Variable variable02 = new Variable();
        // 非静态成员变量x的值 >>> 1
        // 静态成员变量y的值 >>> 1
        variable01.fun07();
        // 非静态成员变量x的值 >>> 1
        // 静态成员变量y的值 >>> 2
        variable02.fun07();
        // 非静态成员变量x的值 >>> 2
        // 静态成员变量y的值 >>> 3
        variable01.fun07();
        // 非静态成员变量x的值 >>> 2
        // 静态成员变量y的值 >>> 4
        variable02.fun07();
    }
}

Test01输出结果：

fun01()中a的值 >>> 10
fun02()中a的值 >>> 20
fun03()中a的值 >>> 30
成员变量count的值 >>> 0
成员变量count的值 >>> 0
成员变量count的值 >>> 2

Test02输出结果：

成员变量count的值 >>> 1
成员变量count的值 >>> 2

Test03输出结果：

成员变量count的值 >>> 1
成员变量count的值 >>> 2
成员变量count的值 >>> 1

Test04输出结果：

非静态成员变量x的值 >>> 1
静态成员变量y的值 >>> 1
非静态成员变量x的值 >>> 1
静态成员变量y的值 >>> 2
非静态成员变量x的值 >>> 2
静态成员变量y的值 >>> 3
非静态成员变量x的值 >>> 2
静态成员变量y的值 >>> 4
 

注意：

成员变量中y被static静态修饰符修饰后，它的存储地址就不在堆内存中了，而y会存储在另一个新的存储区域内，

此时Variable01() 和 Variable02(）会轮番调用在新区域内的y，

第一次被Variable01()调用后++，y变为1，

第二次被Variable02()调用后++,变为2，以此类推，最终为4。

非静态成员变量仅仅能在对象内部共享数据 而静态成员变量可以在多个对象之间共享数据 三.匿名对象( 没有引用类型变量指向的对象) 

先创建一个Temp类

package com.lzy.bean;


public class Temp {
    public void laugh(){
        System.out.println("二十四笑头一笑，仰天长笑");
    }
}

再在测试包中的TempTest类中调用Temp类

调用对象时不用实例化（如下面代码的比较）

package com.lzy.bean;

import org.junit.jupiter.api.Test;


public class TempTest {
    @Test
    public void test01() {
        Temp temp = new Temp();
        temp.laugh();
        temp.laugh();
        temp.laugh();
    }

    @Test
    public void test02() {
        // Temp temp = new Temp();
        // temp.laugh();
        new Temp().laugh();
    }
}

Test01输出结果：

二十四笑头一笑，仰天长笑
二十四笑头一笑，仰天长笑
二十四笑头一笑，仰天长笑

Test02输出结果：

二十四笑头一笑，仰天长笑