equals 方法

1. equals是方法，不是运算符

2. equlas 是 Object 中的方法，只能用来判断引用类型

3. 默认判断的是内存地址是否相等，Object中有许多子类，而这些子类往往会重写 equals 方法

4. equals 用来判断内容是否相等

5. equals 比较的方法，判断传入的值是否相等，不管是否为两个新的对象

   Integer integer = new Integer(1000);
   Integer integer1 = new Integer(1000);
   System.out.println(integer.equals(integer1));   // true

   // 两种写法都可以，但推荐这样写 "jack".equals(name)
   			name.equals("jack")
   // 实际开发中一般使用的是下面这种写法，因为这样写可以避免空指针的问题
   			"jack".equals(name)
                
                // 两个引用类型进行比较
                String name = "nihao";
   			String name1 = "nihao";
   			name.equals(name1)

equals 细节

1. 不同的对象内存地址不同，但是这里是特殊情况，同一字符串在常量词中只出行一次
2. equals默认是比较两个对象的内存地址是否相等的

重写equals

判断两个类里面的属性是否相等

例子：

public class Doctor {
    private String name;
    private int age;
    private String job;
    private char gender;
    private double salary;

    public Doctor(String name, int age, String job, char gender, double salary) {
        this.name = name;
        this.age = age;
        this.job = job;
        this.gender = gender;
        this.salary = salary;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getJob() {
        return job;
    }

    public void setJob(String job) {
        this.job = job;
    }

    public char getGender() {
        return gender;
    }

    public void setGender(char gender) {
        this.gender = gender;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

//    重写父类的equals方法，所以当我们调用equals方法的时候会调用重写好的equals方法
//    而本类中调用equals方法则是正常调用父类（Object）中的equals方法，而不是调用重写的equals方法
    @Override
    public boolean equals(Object obj) {
//        判断当前对象和传进来的对象是不是同一类（相同类或则子类则判断为是同一个对象）
        if (this == obj) {
            return true;
        }
//        判断传进来的对象是否属于Doctor对象，该步骤是为了防止obj是Doctor的子类
        if (!(obj instanceof Doctor)) {
            return false;
        }
//        这一步是调用obj里面的属性，obj属于Doctor类，所有这里可以使用向下转型进行调用obj的属性，方便进行判断
        Doctor doctor = (Doctor) obj;
        return this.name.equals(doctor.name) && this.age == doctor.age &&
                this.job.equals(doctor.job) && this.gender == doctor.gender &&
                this.salary == doctor.salary;
    }
}

public class judg {
    public static void main(String[] args) {
        Doctor doctor1 = new Doctor("张三", 20, "网络工程师", '男', 15000);
        Doctor doctor2 = new Doctor("张三", 20, "网络工程师", '男', 15000);
//        doctor1相当于equals方法中的this，doctor2相当于equals方法中的obj
        System.out.println(doctor1.equals(doctor2));
//        下面这行代码也可以调用doctor2里面的属性（向下转型）
//        所以现在doctor2和下面的doctor都可以调用doctor2里面的属性以及方法
//        Doctor doctor = (Doctor) doctor2;

        System.out.println(doctor1 == doctor2);

        int a = 1;
        int b = 2;

        String n = "n";
        String m = "n1";
        System.out.println(n.equals(m));
        System.out.println(n == m);

    }
}