Java面向对象——多态、Object类、instanceof关键字以及final关键字

多态的概念

1.多态是指同一个方法调用可以在不同的对象上有不同的表现，即同一种方法调用方式适用于不同的数据类型。
编译时和运行时：
	编译时期调用的是父类中的方法，但运行时期会根据实际的对象类型来调用适当的方法。
	这种行为称为动态绑定，即运行时决定调用哪个方法。
2.接口也可以实现多态性。
3.实现多态的条件：
	继承关系、方法重写，以及父类引用指向子类对象是实现多态性的关键条件。
4.父类引用指向子类对象：
	可以使用父类的引用来指向子类的对象，这样就可以通过统一的接口来调用不同子类的方法。
	子类继承父类，并且子类重写父类的方法。
	此处，需要注意的是如果向上转型后，父类需要调用子类新增的方法，
可以通过向下转型的方法【即把父类转换为子类实现】
4.1向上转型：
	将子类的对象赋值给父类的引用称为向上转型。这种转型不需要显式地进行，编译器会自动进行类型检查。
4.2向下转型：
	将父类的引用转为子类的引用称为向下转型。需要使用强制类型转换，但在进行之前最好使用 instanceof 进行类型检查，以避免异常。
**口诀：【调用实例方法看等号==右边】【调用静态方法看等号==左边】**

总之，多态是面向对象编程中一个非常重要的概念，通过它可以实现统一的接口来操作不同的对象，提高代码的可读性和可维护性。在实际编程中，多态性的使用可以使代码更加灵活和扩展性更强。方法重写是实现多态的基础。

instanceof关键字的介绍

instanceof 用于在运行时检查一个对象是否是特定类的实例，或者是否实现了特定接口。
1. 判断对象是否是特定类的实例：
2. 判断对象是否实现了特定接口：
3. 多层次继承中的判断： instanceof 也可以在多层次继承关系中使用。
4. 避免滥用 instanceof： 虽然 instanceof 可以用于类型检查。但在面向对象的设计中，通常应该倾向于使用多态和继承来避免大量的 instanceof 检查。
5. 使用 instanceof 与类型转换： instanceof 可以与类型转换（强制类型转换）一起使用，以确保转换的安全性。

final关键字

1. final 变量： 用于声明一个常量，一旦赋值后就不能再修改。
2. final 方法： 用于阻止子类对该方法的重写（覆盖）。
3. final 类： 用于表示一个类不能被继承。
4. final 参数： 用于表示方法参数在方法内不能被修改。
5. final 引用： 用于表示引用指向的对象不能被修改，但对象本身的属性可以被修改（对于非基本类型）。
6. final 静态变量： 用于表示一个静态变量是一个常量，通常用大写命名。
7. final 数组： 用于表示数组引用不可更改，但数组内的元素可以更改。

Object类

1. equals(Object obj) 方法：
	用于比较两个对象是否相等。默认情况下，它比较的是对象的引用，但你可以在你的类中重写这个方法以自定义比较逻辑。
2. hashCode() 方法：
	返回对象的哈希码值。在使用集合（如哈希表）时，哈希码用于确定对象在内存中的存储位置。
3. toString() 方法：
	返回对象的字符串表示。默认情况下，这是对象的类名 + @ + 对象的哈希码。你可以在你的类中重写这个方法，以便自定义字符串表示。
4. getClass() 方法：
	返回对象所属的类的 Class 对象。Class 对象提供了有关类的信息，包括类名、方法、字段等。
5. wait(), notify() 和 notifyAll() 方法：
	用于在多线程环境下进行线程通信。这些方法只能在同步代码块中使用，用于唤醒等待中的线程。而且通常与锁机制一起使用。
6. wait() 方法：
	用于在线程之间进行等待，直到其他线程唤醒它。也需要在同步代码块中使用。
7. finalize() 方法：
	通常不建议使用，因为 Java 中的垃圾回收机制会自动释放对象占用的资源。
	由垃圾回收器在回收对象之前调用。通常不建议使用，因为不同的 JVM 行为可能不同。
8. clone() 方法：
	用于创建并返回对象的副本。需要注意的是，这个方法的默认实现是浅拷贝，即对象内部的引用也会被共享。
关于equals方法的重写：
	/**
 * 重写 equals 要求：
 * 对 null 返回 false
 * 自反性：x.equals(x) 返回true
 * 对称性： x.equals(y) 的值 和 y.equals(x) 的值一样
 * 传递性： x.equals(y) 为 true, y.equals(z) 为 true, 此时 x.equals(z) 为 true
 * 一致性： x.equals(y) 多次调用结果一致
 *  重写了 equals 就要重写 hashCode    
 *  */ 

重写如下所示

@Override
    public boolean equals(Object obj) {
        // this【当前对象】   obj【需要比较的对象】
        if (obj == null) {
            return false;
        }
        if (this == obj) {
            return true;
        }
        // 学生是同一个对象要求是 学号一样就是同一个
        // 类型转换, 有继承关系 向上转型 和 向下转型
        // Student --> Object  向上转型
//        Object o = this;

        // Object --> student 向下转型 强制类型转换

        Student stu = (Student) obj;

        if (stu.id == this.id || stu.id.equals(this.id)) {
            return true;
        }
        return false;
    }

关于hashCode方法的重写：

 /*
        equals 结果为 true hashCode 值一样
        hashCode 一样 equals 结果不一定
     */
    @Override
    public int hashCode() {
       int result = 1;
       result = 31 * result + name.hashCode();
       result = 31 * result + age;
       result = 31 * result + gender;
       result = 31 * result + id.hashCode();

       return result;
    }

重写toString方法：

@Override
  public String toString() {
      return "Student{" +
              "name='" + name + '\'' +
              ", age=" + age +
              ", gender=" + gender +
              '}';
  }