【面向对象】面向对象三大特征之——多态 实现多态的基础:方法重写

方法重写

方法的重写或方法的覆盖（overriding）

子类根据需求对从父类继承的方法进行重新编写，重写时，可以用super.方法的方式来保留父类的方法，构造方法不能被重写。

方法重写规则

• 在子类与父类之间
• 方法名相同
• 参数列表相同（参数个数和类型相同）
• 返回值类型相同或者是其子类
• 访问权限不能严于父类

其他注意事项

• 父类的静态方法不能被子类覆盖为非静态方法,父类的非静态方法不能被子类覆盖为静态方法
• 子类可以定义与父类同名的静态方法，以便在子类中隐藏父类的静态方法(注：静态方法中无法使用super)
• 父类的私有方法不能被子类覆盖
• 不能抛出比父类方法更多的异常

方法重写示例

// 父类
class Animal {
    // 父类的方法
    void makeSound() {
        System.out.println("Some sound");
    }
}

// 子类
class Dog extends Animal
    @Override
    void makeSound() {
        System.out.println("Bark");
    }
}
public class Main {
    public static void main(String[] args) {
        Animal myDog = new Dog(); // 向上转型
        myDog.makeSound();  // 输出: Bark
    }
}

使用 @Override 注解可以帮助编译器检查子类的方法是否真的重写了父类的方法。如果没有正确重写，编译器会提示错误。

方法重写 vs 方法重载

比较项	位置	方法名	参数表	返回值	访问修饰符
方法重写	子类	相同	相同	相同或是其子类	不能比父类更严格
方法重载	同类	相同	不相同	无关	无关

Object

Object 类是超类(基类)，是所有类的父类，Java中所有的类都直接或者间接继承 object

public class Pet extends Object {
	// ......
}

Object 类被子类经常重写的方法

方法	说明
toString()	返回当前对象本身的有关信息，按字符串对象返回
equals()	比较两个对象是否是同一个对象，是则返回true
hashCode()	返回该对象的哈希代码值
getClass()	获取当前对象所属的类信息，返回Class对象

equals()

（1）Object 类的equals()方法与操作符==没区别

（2）当有特殊需求，如认为属性相同即为同一对象时，需要重写 equals()

（3）Java.lang.String重写了 equals() 方法，把 equals() 方法的判断变为了判断其值

重写 equals() 方法

@Override
public boolean equals(Object obj){
    if (this == obj) {
        return true;
    }
    if (obj instanceof Student) {
        Student other = (Student) obj;
        return Id.equals(other.Id) && name.equals(other.name);
    }
    return false;
}

多态

多态：同一个引用类型，使用不同的实例而执行不同操作

使用多态优化可解决的问题：频繁修改代码，代码可扩展性、可维护性差

使用多态优化前的代码

//给狗看病
public void cure(Dog dog) {
    if (dog.getHealth() < 50) {
        dog.setHealth(60);
        System.out.println("打针、吃药");
    }
}
//给企鹅看病
public void cure(Penguin penguin){
    if (penguin.getHealth() < 50) {
        penguin.setHealth(70);
        System.out.println("吃药、疗养");
    }
}

使用多态优化后的代码

// pet类（父类） 
public class Pet {
    public void toHospital() {} // toHospital()不需要有具体的实现，此可以将其定义为抽象方法，Pet类声明为抽象类（实例化Pet毫无意义）
}
//　Dog类（子类）
public class Dog extends Pet {
    public void toHospital() {
        this.setHealth(60);
        System.out.println("打针、吃药");
    }
}
// Penguin类（子类）
public class Penguin extends Pet {
    public void toHospital() {
        this.setHealth(70);
        System.out.println("吃药、疗养");
    }
}
// Master类
public class Master {
    public void cure(Pet pet) {
        if (pet.getHealth() < 50)
            pet.toHospital();        
    }
}
// 测试方法
public static void main(String[] args) {
    Master master = new Master();
    Pet dog = new Dog(); // 向上转型
    Pet penguin = new Penguin();
    master.feed(dog);
    master.feed(penguin);
}

再某新类看病时，只需编写该类继承Pet类（旧方案也需要），创建该类对象（旧方案也需要） 。而其他代码不变，即不用修改 Master 类

方法重写是实现多态的基础

使用父类作为方法的形参，是 Java 中实现和使用多态的主要方式

使用父类作为方法的返回值，也是 Java 中实现和使用多态的主要方式

向上转型

父类的引用指向子类对象。

子类转父类，自动类型转换

<父类型> <引用变量名> = new <子类型>();

//测试方法
Pet pet = new Dog();
// 相当于:Dog dog = new Dog(); Pet pet = dog; 
pet.setHealth(20);
Master master = new Master();
master.cure(pet);

• 此时通过父类引用变量调用的方法是子类覆盖或继承父类的方法，不是父类的方法

• 此时通过父类引用变量无法调用子类特有的方法

• 如果需要调用子类特有的方法，可以通过向下转型

向下转型

将一个指向子类对象的父类引用赋给一个子类的引用。

父类转子类，强制类型转换

<子类型> <引用变量名> = (<子类型> )<父类型的引用变量>;

Dog dog = (Dog) pet;    // 将 pet 转换为 Dog 类型
dog.catchingFlyDisc();  // 执行 Dog 特有的方法

在向下转型的过程中，如果没有转换为真实子类类型，会出现类型转换异常。可以通过Java提供的 instanceof 运算符来进行类型的判断，从而减少在向下转型的过程中，没有转换为真实子类类型的类型转换异常

instanceof

Java 中的一个运算符，用于检查对象是否是某个类或接口的实例。

语法：对象 instanceof 类名，如果对象是该类的实例或其子类的实例，表达式返回 true，否则返回 false。

使用 instanceof 时，对象的类型必须和 instanceof 后面的参数所指定的类在继承上有上下级关系

使用场景

public void cure(Pet pet){
    // 判断 pet 中是 dog 还是 penguin
    if(pet instanceof Dog){
        Dog dog = (Dog) pet;
        dog.feed();
    }else if(pet instanceof Penguin){
        Penguin penguin = (Penguin) pet;
        penguin.feed();
    }
}