instanceof、==和 equals

ps:看了b站韩顺平的一些理解，哪里错了感谢指正。

instanceof

比较操作符，用来判断对象的运行内存是否是某类型或某类型的子类。

• 编译类型看定义时=左边，运行类型看定义时=右边

  Animal animal = new Dog()
  

  编译类型：Animail

  运行类型：Dog

eg:重写equals方法来判断两个Person对象是否相等，代码如下

public class EqualsExercise {
    public static void main(String[] args) {
        Person person1 = new Person("新一", 18, '女');
        Person person2 = new Person("新一", 18, '女');
        //Person person2 = new Person("新二", 21, '男');
        System.out.println(person1.equals(person2));

    }
}

class Person {
    private String name;
    private int age;
    private char gender;

    public Person(String name, int age, char gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        //先进行类型判断！！
        if (obj instanceof  Person){
            Person person = (Person) obj;
            if (this.name.equals(person.name) && this.age == person.age && this.gender == person.gender) {
                return true;
            }
        }

        return false;
    }

    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 char getGender() {
        return gender;
    }

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

• 重写equals的理解

  1. 首先if语句判断传入的person2对象是否和当前person1对象是同一个对象，是则直接返回true

  2. 若不是同一个对象，则先通过instanceof判断obj是否是Person类或Person类的子类。

     • main方法中person1.equals(person2)执行后person对象自动向上转型：

       Object obj = Person person2
       

       obj的编译类型为Object 运行类型为：Person，

       instanof比较时看的是运行类型

       obj instanceof  Person  //上述代码比较中为true
       

     为真 进行向下强转 将Object转为Person类型（需要得到obj的各个属性）

  3. 然后比较当前person1对象和 person对象各个属性是否相等

==和 equals 的对比

• ==

  1. 既可以判断基本类型，又可以判断引用类型
  2. 如果判断基本类型，则判断值是否相等。
  3. 如果判断引用类型，判断的是地址是否相等，即判断是不是同一个对象

• equals

  1. 是Object类中的方法，只能判断引用类型。（idea中Ctrl+B查看源码）
  2. 默认（Object）判断的是地址是否相等。子类往往重写该方法来判断内容是否相等，eg：String、Integer。

  Object中equals源码：

  public boolean equals(Object obj) {
          return (this == obj); //此对象this和传入的obj为引用类型， 所以比较二者是否是同一个对象
      }
  

  String中equals源码：

  //重写Object的equals方法，为比较两个字符串值是否相同
  public boolean equals(Object anObject) {
          if (this == anObject) {  //判断是否是同一个对象
              return true;
          }
          if (anObject instanceof String) {  //判断是否是String类或String子类
              String anotherString = (String)anObject;  //向下强转
              int n = value.length;
              if (n == anotherString.value.length) { //比较二者长度是否相等
                  char v1[] = value;
                  char v2[] = anotherString.value;
                  int i = 0;
                  while (n-- != 0) {  //比较字符串每位字符是否相等
                      if (v1[i] != v2[i])
                          return false;
                      i++;
                  }
                  return true;
              }
          }
          return false;
      }
  

  Integer中equals源码：

  //重写Object的equals方法，，为比较两个值是否相同
  public boolean equals(Object obj) {
          if (obj instanceof Integer) { 
              return value == ((Integer)obj).intValue();
          }
          return false;
      }
  

  eg:

  public class Equals2 {
      public static void main(String[] args) {        
          Person p1 = new Person(); 
          p1.name = "xinyi";
          Person p2 = new Person();
          p2.name = "xinyi"; 
          System.out.println(p1==p2); //False 
          //比较引用类型，比对象。new了两个不同对象
          System.out.println(p1.name .equals( p2.name));//T 
          //比较字符串类型，比值。值相等
          System.out.println(p1.equals(p2));//False 
          //比Person类，Person类中没有重写equals方法，默认为Object类中的equals方法，比较对象是否相同。
  
  
          String s1 = new String("abc"); 
          String s2 = new String("abc"); 
          System.out.println(s1.equals(s2));//T 
          //比String类，String类中重写了equals方法，比较两个字符串值是否相同
          System.out.println(s1==s2); //F
          //比对象
        }
        
        class Person{
          public String name;
      }
  }