【equals比较方法 和 内部类】

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

---

前言

对象比较equals方法

三种比较相等方法：
第一种，如果==两侧是基本数据类型，则比较变量的值是否相等
第二种，如果 == 两侧是引用数据类型，则比较引用变量的地址是否相等
第三种，如果要比较引用对象的值是否相等，则要重写Object中的equals方法

class Student{
    public String name;
    public int age;
    //构造方法初始化成员变量
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    //重写toString方法
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    //重写equals方法
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age && Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}
public class Test {
    public static void main(String[] args) {
        Student student = new Student("藏三",6);
        Student student2 = new Student("藏三",6);
        //只是比较地址一样不一样
        System.out.println(student==student2);
        //这才是比较对象一样不一样
        System.out.println(student.equals(student2));
    }
}

结论：比较对象中内容是否相同的时候，一定要重写equals方法。

内部类

可以将一个类定义在另一个类或者一个方法的内部，
前者称为内部类，后者称为外部类
【注意事项】

1. 定义在class 类名{}花括号外部的，即使是在一个文件里，都不能称为内部类
2. 内部类和外部类共用同一个java源文件，但是经过编译之后，内部类会形成单独的字节码文件

实例内部类

即未被static修饰的成员内部类

// OutClass是外部类
// InnerClass是内部类
class OutterClass{
    public int date1 = 9;
    public static int date2 = 77;
    private  int date3 =66 ;
    public void test(){
       InnerClass innerClass = new InnerClass();//在外部类实例化实例内部类
        System.out.println("OutterClass:test()");

    }
    //实例内部类：即未被static修饰的成员内部类。
    class InnerClass{
        public int date1 = 111;
        public int date4 = 44;
        public static final int date5 = 10;
        private int date6 = 7;

        public void test(){
            System.out.println("InnerClass:test()");
            System.out.println(date1);//实例内部类有date1，外部类也有date1，优先访问实例内部类的
            System.out.println(OutterClass.this.date1);//访问外部类,用外部类类名点this点变量名
            System.out.println(date2);
            System.out.println(date3);
            System.out.println(date4);
            System.out.println(date5);
            System.out.println(date6);
        }
    }
}
public class Test {
    public static void main(String[] args) {

        OutterClass outterClass = new OutterClass();
        //实例化实例内部类对象
        //要先实例化外部类对象，
        // 然后在实例化内部类的=号左边加大驼峰外部类类名和.  右边加小驼峰外部类类名和.
        OutterClass.InnerClass innerClass = outterClass.new InnerClass();
        innerClass.test();

    }
}

静态内部类

class OuterClass{
    public int date1 = 1;
    private int date2 = 2;
    public static int date3 = 3;

    //静态内部类
    static class InterClass{
        public int  date4 = 4;
        public static int date5 = 5;
        private  int date6 = 6;

        public void test(){
            System.out.println("InterClass:test()");
//            System.out.println(date1);//不能调用非静态的成员变量
//            System.out.println(date2);
            //可以用外部类间接访问
            OuterClass outerClass = new OuterClass();
            System.out.println(outerClass.date1);
            System.out.println(outerClass.date2);
            
            System.out.println(date3);
            System.out.println(date4);
            System.out.println(date5);
            System.out.println(date6);
        }
    }
    public void test(){
        System.out.println("OuterClass:test()");
    }
}

public class Test {
    public static void main(String[] args) {

        //静态内部类的实例化
        OuterClass.InterClass interClass = new OuterClass.InterClass();
        interClass.test();
    }
}

匿名内部类

（多线程常用）

//匿名内部类
interface IA{
    void teat();
}
public class Test {
    public static void main(String[] args) {
        IA a = new IA() {
            @Override
            public void teat() {
                System.out.println("重写了接口方法");
            }
        };
        a.teat();

    }

}

总结

equals比较方法最核心是要重写Object中的equals方法，还有明白什么是外部类，内部类，以及实例内部类，静态内部类。