【一步一步了解Java系列】：重磅多态-阿里云开发者社区

看到这句话的时候证明：此刻你我都在努力

加油陌生人

何为多态

在Java中，多态（Polymorphism）是一种允许不同类的对象对同一消息做出响应的能力，即同一个接口可以被不同的实例以不同的方式实现。多态性是面向对象编程的一个核心概念，它使得代码更加灵活和可扩展。

多态性主要通过以下几种方式实现：

方法重载（Overloading）：这是编译时多态的一个例子。方法重载允许同一个类中有多个同名方法，只要它们的参数列表不同（参数的类型、数量或顺序不同）。

方法重写（Overriding）：这是运行时多态的一个例子。当子类继承父类时，子类可以重写父类的方法。如果子类对象调用了一个被重写的方法，将执行子类中的方法实现，而不是父类中的实现。

接口实现：一个类可以实现一个或多个接口，接口定义了一组方法规范，具体的实现类必须提供这些方法的具体实现。不同的实现类可以以不同的方式实现同一个接口中定义的方法。

抽象类：抽象类可以包含抽象方法，这些方法没有具体的实现，必须由继承抽象类的子类来实现。这也是一种多态的体现，因为不同的子类可以提供不同的实现。

多态的使用可以带来以下好处：

代码复用：通过继承和接口实现，可以减少代码的重复编写。

扩展性：通过多态，可以在不修改现有代码的情况下，引入新的类和对象。

灵活性：多态允许程序在运行时动态地绑定方法调用，使得程序更加灵活。

多态是Java中实现开闭原则（对扩展开放，对修改封闭）的关键机制之一，它允许程序更容易适应变化，同时保持代码的稳定性和可维护性。

多态实现的条件：

必须在继承体系下

子类必须要对父类中方法进行重写

通过父类的引用调用重写的方法

总的来说：多态即是不同对象，不同的的态度。

方法重载的多态

方法重载在前面其实已经说过了，下面是一个方法重载多态的情况：

public class Cat {

    String type="猫咪";
    public void eat(){
        System.out.println(type+"吃猫粮");

    }


    public void eat(int n){

        System.out.println(type+"吃"+n+"两猫粮");

    }

}

class Test{
    public static void main(String[] args) {
        Cat cat=new Cat();
        cat.eat();
        cat.eat(1);

    }


}

上面我们对方法进行重载，然后传参不同时，同一个方法却呈现不同的打印方式即（不同的形态）。

方法重写的多态

我们先要认识，何为重写：

在Java中，重写（Overriding）是指子类提供一个特定的实现，覆盖从父类继承来的方法的实现。这是运行时多态的一个体现，意味着在程序运行时，会根据对象的实际类型来调用相应的方法。

要实现方法重写，需要满足以下条件：

方法名、参数列表和返回类型：子类重写的方法必须具有与父类被重写方法相同的方法名、参数列表和返回类型。如果返回类型不同，则不是重写，而是重载（Overloading）。

访问权限：子类重写的方法不能具有比父类更严格的访问权限。例如，如果父类中的方法是public的，子类重写的方法也必须是public或protected，但不能是private。

非静态方法：重写必须发生在非静态方法上。静态方法（Static methods）不能被重写。

非最终方法：如果父类中的方法是final的，则不能被重写。

下面是一个简单的示例，展示如何在Java中重写方法：

class Animal {
    public void sound() {
        System.out.println("Animal makes a sound");
    }
}

class Dog extends Animal {
    @Override // 这是一个注解，用于指示该方法重写了父类的方法
    public void sound() {
        System.out.println("Dog barks");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal myAnimal = new Dog(); // 向上转型
        myAnimal.sound(); // 输出 "Dog barks"，展示了运行时多态
    }
}

在这个例子中，Dog 类继承自 Animal 类，并重写了 sound() 方法。当我们创建 Dog 类的实例并将其向上转型为 Animal 类型时，调用 sound() 方法会执行 Dog 类中重写的方法，而不是 Animal 类中的原始方法。这就是多态性的一个典型应用，它允许程序在运行时根据对象的实际类型来确定调用哪个方法。

了解完重写我们在看看，下面的代码：

public class Animal {
    String name="aaaa";

    public void eat(){
        System.out.println("吃东西。。。。。");

    }
}


class Dog extends Animal{

    String name;

    public Dog(String name) {
        this.name = name;
    }

    public void eat(){
       System.out.println("吃狗粮。。。");


    }




}

class Cat extends Animal{

    String name;

    public Cat(String name) {
        this.name = name;
    }

    public void eat(){
        System.out.println("吃猫粮。。。");


    }




}

class Test{

    public static void main(String[] args) {
        Animal animal=new Dog("旺财");
       animal.eat();
        animal=new Cat("小黑");
        animal.eat();
     
    }



}

我们在调用eat（）方法时却呈现了不同的形态，即：一个吃猫粮，一个吃狗粮。

我们也可以用静态方法实现多态如下：

public class Animal {
    String name="aaaa";

    public void eat(){
        System.out.println("吃东西。。。。。");

    }
}


class Dog extends Animal{

    String name;

    public Dog(String name) {
        this.name = name;
    }

    public void eat(){
        System.out.println("吃狗粮。。。");


    }




}

class Cat extends Animal{

    String name;

    public Cat(String name) {
        this.name = name;
    }

    public void eat(){
        System.out.println("吃猫粮。。。");


    }




}

class Test{
public static void eat(Animal animal){
    animal.eat();

}
    public static void main(String[] args) {
        Dog dog=new Dog("旺财");
       eat(dog);
       Cat cat=new Cat("小黑");
       eat(cat);

    }



}

这里我们在Test中实现了一个静态方法eat（Animal animal）然后传递一个对象进去即可完成多态。

其实上面的代码还涉及了，类的向上转型。我们接下来就讲讲向上转型和向下转型。

向上转型和向下转型

在Java中，向上转型（Upcasting）和向下转型（Downcasting）是面向对象编程中多态性的一部分，它们允许我们处理不同类型的对象，但以更通用的类型进行操作。

向上转型（Upcasting）

向上转型是指将子类对象赋值给父类引用的过程。向上转型是安全的，因为子类是父类的特化。这意味着子类继承了父类的所有属性和方法，所以子类对象可以被看作是父类对象。

示例代码：

class Animal {
    void makeSound() {
        System.out.println("Animal makes a sound");
    }
}

class Dog extends Animal {
    void makeSound() {
        System.out.println("Dog barks");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal myAnimal = new Dog(); // 向上转型
        myAnimal.makeSound(); // 将调用Dog类的makeSound方法
    }
}

在这个例子中，Dog 类是 Animal 类的子类。我们创建了一个 Dog 类的实例，并将这个实例赋值给 Animal 类型的引用 myAnimal。由于向上转型是安全的，编译器允许这样做，并且当我们调用 makeSound() 方法时，将调用 Dog 类中重写的方法。

向下转型（Downcasting）

向下转型是指将父类对象赋值给子类引用的过程。向下转型是不安全的，因为父类引用可能没有指向实际的子类对象。如果向下转型不正确，将会导致 ClassCastException。

示例代码：

class Animal {
    void makeSound() {
        System.out.println("Animal makes a sound");
    }
}

class Dog extends Animal {
    void makeSound() {
        System.out.println("Dog barks");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal myAnimal = new Dog();
        Dog myDog = (Dog) myAnimal; // 向下转型

        if (myAnimal instanceof Dog) {
            Dog myDogSafe = (Dog) myAnimal; // 安全的向下转型
            myDogSafe.makeSound(); // 将调用Dog类的makeSound方法
        } else {
            System.out.println("myAnimal is not a Dog");
        }
    }
}

在这个例子中，我们首先向上转型，将 Dog 对象赋值给 Animal 类型的引用 myAnimal。然后我们尝试向下转型，将 myAnimal 转换为 Dog 类型的引用 myDog。如果 myAnimal 实际上指向了一个 Dog 对象，那么向下转型将成功，否则将抛出 ClassCastException。

为了安全地进行向下转型，可以使用 instanceof 操作符来检查 myAnimal 是否确实指向了一个 Dog 对象。如果 instanceof 检查为 true，那么向下转型是安全的。

注意：

向上转型后只能调用父类的成员和方法，无法再调用子类特有的成员变量或方法。

一个小坑

避免在调用构造方法时调用已经重写过的方法，否则很容易出错。

如下代码：在实例化子类对象时，我们必须先调用完成父类的构造方法，然而Animal的构造方法又调用了子类的已经重写的方法func，这时发生动态绑定，方法执行重写的func，而此时num的值未完成初始化，就打印了0出来，所以打印结果就如下图：

public class Test {

    public static void main(String[] args) {
        Dog dog=new Dog();

    }
}

class Animal{

public void func(){
    System.out.println("动物");
}

public Animal(){
    func();
}


}


class Dog extends Animal{

    int num=999;
    public void func(){
        System.out.println("狗");
        System.out.println(num);
    }


}