JAVA面向对象的简单介绍（二)

一：堆内存与栈内存

               先创建一个Dog类，标注它的属性(特征即属性)和方法(行为即方法)

public class Dog {
    
    String breed;
    
    int size;

    
    String color;

    
    int age;

    public void eat(){

    }

    public void run(){

    }

    public void sleep(){

    }
}

然后在 Test包中 实例化出两个对象（dog01和dog02）,输出并判断它们是否相等 结果肯定为false

import org.junit.jupiter.api.Test;

public class DogTest {

    @Test
    public void test01(){
        Dog dog = new Dog();
    }
    @Test
    public void test02(){
        Dog dog01 = new Dog();
        Dog dog02 = new Dog();
        System.out.println(dog01 == dog02);
    }

    @Test
    public void test03(){
        Dog dog01 = new Dog();
        Dog dog02 = new Dog();
        System.out.println(dog01 == dog02);
    }

}

原因：栈中的dog01会指向堆中的newDog(),栈中的dog02会指向堆中的一个新的            newDog(),dog01 和  dog02在堆中的存储空间地址不同，因为是一一对应            的关系，所以会出现两个newDog()存储空间，所以二者不会相等。

 二：静态方法与非静态方法：         先创建一个Person类，标注它的属性(特征即属性)和方法(行为即方法)         然后给sleep方法加上static静态修饰符

public class Person {
 
    String nickname;
    
    int gender;
    
    int age;

    public  void eat(){
        System.out.println("一顿不吃饿得慌");
    }
    public  static  void sleep(){
        System.out.println("在哪里跌倒，就在那里睡一觉");
    }
    public void run(){
        System.out.println("跑过博尔特");
    }

}

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

public class Person01Test {
    @Test
    public void test01(){
        // 静态方法可以通过类名点方法名的方式调用
        // 但是不能通过类名点方法名的方式调用非静态方法
        Person.sleep();
    }

    @Test
    public void test02(){
        // 静态方法可以通过类名点方法名的方式调用
        // 但是不能通过类名点方法名的方式调用非静态方法
        Person.sleep();
        Person person01 = new Person();
        // 可以通过类的实例化对象名点方法名的方式调用静态方法
        // 也可以通过类的实例化对象名点方法名的方式调用非静态方法
        person01.eat();
        person01.run();
        person01.sleep();
    }
}

 三：成员变量与局部变量以及二者之间的区别：           首先创建一个Variable类         在方法之中，类之内，声明啦三个数据类型为int的变量         count,x,未用静态修饰符修饰  而y用静态修饰符修饰，         用于测试包中体现调用成员变量时的区别

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类里的方法, 注意：调用成员变量和局部变量的区别，以及调用成员变量和成员变量之间的区别。

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

注意：成员变量中y被static静态修饰符修饰后，它的存储地址就不在堆内存中啦             而y会存储在另一个新的存储区域内，此时Variable01() 和 Variable02()             会轮番调用在新区域内的y，第一次被Variable01()调用后++，y变为1，第二次             被Variable02()调用后++,变为2，以此类推，最终为4。              非静态成员变量仅仅能在对象内部共享数据              而静态成员变量可以在多个对象之间共享数据   四：匿名对象( 没有引用类型变量指向的对象)         先创建一个Temp类

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

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

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

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

}