Java的多态

一、多态的概念

多态性是指同一操作或方法可以在不同的对象上具有不同的行为。它允许我们通过使用基类或接口类型的引用变量来调用子类或实现类的方法。

二、多态的作用

多态性是面向对象编程中的一个重要概念，它可以让我们以一种统一的方式处理不同类型的对象。多态性有助于实现代码的灵活性、可扩展性和可维护性。在 Java 中，多态性通过方法的重写和继承来实现。

三、实现多态的条件

1、父类型引用指向子类型对象：可以使用父类或接口类型的引用变量来引用子类或实现类的对象。同时这句话就是多态的主要核心

2、方法重写：子类可以根据自己的需求重写父类的方法。重写的方法在运行时将根据对象的实际类型来确定调用哪个方法。

四、运行时和编译时多态

1、编译时多态（静态多态）：
编译时多态是指在编译阶段确定方法的调用，根据引用变量的声明类型来确定调用哪个方法。这种多态性是通过方法重载实现的，编译器根据方法签名选择合适的方法进行绑定。
例如，如果有一个父类类型的引用变量，但是它引用的是子类对象，那么在编译时，编译器只知道引用变量的类型是父类，会根据父类的方法签名选择合适的方法进行绑定。
2、运行时多态（动态多态）：
运行时多态是指在程序运行阶段确定方法的调用，根据实际对象的类型来确定调用哪个方法。这种多态性是通过方法重写（覆盖）实现的，运行时根据对象的实际类型动态绑定方法。
例如，如果有一个父类类型的引用变量，引用的是子类对象，那么在运行时，根据实际对象的类型来确定调用哪个子类的方法，实现了动态绑定。
运行时多态性是多态性的核心概念，它允许我们在编写代码时只关注父类或接口的声明，并且能够以统一的方式处理不同类型的对象。通过运行时多态，可以实现代码的灵活性和可扩展性，提高代码的复用性和可维护性。
编译时多态性主要体现在方法重载上，它通过在编译阶段根据方法签名选择合适的方法，以满足不同的参数类型和个数。编译时多态性是静态的，由编译器在编译阶段完成，不需要等到运行时。

五、关于多态的简单理解

  想象一下，我们有几种动物：狗、猫和鸟。每种动物都有自己独特的叫声。现在有几个场景：公园、宠物店和动物园。在这些场景中，我们可以听到不同种类的动物发出的叫声。
无论是在公园散步、在宠物店选购宠物还是在动物园观赏动物，我们都能以相同的方式感受和识别动物的叫声。
  在这个例子中，动物可以类比为父类（例如，Animal），而不同种类的动物可以类比为子类（例如，Dog、Cat、Bird）。每个动物都有自己的叫声，但它们都实现了父类中的共同方法，比如发出声音。
 通过多态的概念，我们可以以统一的方式处理不同种类的动物，比如监听它们的叫声、记录它们的数量等。无论是什么类型的动物，我们都可以使用相同的接口或方法来操作它们，而无需关心具体是哪种动物。这个类比帮助我们理解多态的实际应用，即通过统一的接口或方法来处理不同类型的对象，提高代码的可复用性和可扩展性。无论是处理交通工具还是动物，多态都为我们提供了一种灵活且统一的编程方式。

代码示例：

public interface Animal {
    void makeSound();
}

public class Dog implements Animal {
    public void makeSound() {
        System.out.println("汪汪汪！");
    }
}

public class Cat implements Animal {
    public void makeSound() {
        System.out.println("喵喵喵！");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal dog = new Dog();
        Animal cat = new Cat();

        dog.makeSound(); // 输出：汪汪汪！
        cat.makeSound(); // 输出：喵喵喵！
    }
}

在上述代码中，Animal 接口定义了一个 makeSound 方法，然后 Dog 和 Cat 类分别实现了 Animal 接口并提供了自己的 makeSound 方法实现。在 Main 类中，我们使用 Animal 类型的引用变量 dog 和 cat 来引用 Dog 和 Cat 对象。通过调用 makeSound 方法，我们可以看到不同类型的对象调用相同的方法，但产生不同的输出。

再比如我要写个货物管理系统，我不想每次增加货物的时候更改太多代码，而使用多态可以处理这种问题，代码示例：

public interface Classic {
    void Buy();
}

public class Fruit implements Classic {
    public void Buy() {
        // Fruit类的Buy方法实现
    }
}

public class Clothing implements Classic {
    public void Buy() {
        // Clothing类的Buy方法实现
    }
}

public class Food implements Classic {
    public void Buy() {
        // Food类的Buy方法实现
    }
}

public class Shop {
    public static void Buying(Classic classic) {
        classic.Buy();
    }
}

public class Sale {
    public void mai() {
        Classic one = new Fruit();
        Classic two = new Clothing();
        Classic three = new Food();

        Scanner in = new Scanner(System.in);
        int s = in.nextInt();
        switch(s) {
            case 1:
                Shop.Buying(one);
                break;
            case 2:
                Shop.Buying(two);
                break;
            case 3:
                Shop.Buying(three);
                break;
            default:
                System.out.println("你输入的商品类不存在，请重新输入");
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Sale sale = new Sale();
        sale.mai();
    }
}

在上述代码中，Classic 接口定义了一个 Buy 方法，然后 Fruit、Clothing 和 Food 类分别实现了 Classic 接口并提供了自己的 Buy 方法实现。在 Shop 类中，有一个 Buying 方法，它接受一个 Classic 类型的参数。这样，无论传递哪种类型的对象（Fruit、Clothing 或 Food），都可以通过调用其 Buy 方法实现多态性。在 Sale 类中，根据用户的输入选择不同的商品类型，然后调用 Shop.Buying 方法，传递相应的商品对象，从而实现多态性。

六、多态的优点

多态性的应用有许多优点，包括：
代码重用：可以通过定义通用的父类或接口来实现代码的重用，减少重复的代码编写。
灵活性：可以在运行时动态地选择调用哪个方法，提供了更大的灵活性和可扩展性。
可维护性：通过多态性，当需要修改或扩展功能时，只需要修改或添加子类，而不需要修改原有的代码。
可替换性：可以使用子类对象替换父类对象，从而实现了对象的替换和可插拔性。
多态性是面向对象编程中非常强大的概念，它提供了一种弹性和扩展性的设计方式。通过合理地应用多态性，我们可以编写出更加灵活和可维护的代码。

七、总结

1、多态性基于继承和方法重写：通过继承，子类可以继承父类的属性和方法，并且可以根据需要重写父类的方法。这样，通过父类引用指向子类对象时，可以根据对象的实际类型来调用适当的方法。
2、父类引用指向子类对象：通过父类或接口类型的引用变量，可以引用子类或实现类的对象。这样做的好处是可以统一处理不同类型的对象，提高代码的灵活性和可复用性。
3、编译时类型和运行时类型：多态性的关键在于运行时的动态绑定。编译时，编译器只知道引用变量的类型是父类或接口，而不知道实际引用的对象类型。运行时，根据实际对象的类型来确定调用哪个方法，这就是动态绑定。
4、多态性提高了代码的可扩展性和可维护性：通过多态性，可以方便地扩展程序，添加新的子类或实现类，并且无需修改现有的代码。这样可以减少代码的耦合性，提高代码的可维护性和可重用性。
5、多态性的应用场景：多态性广泛应用于面向对象的设计和编程中，特别是在设计模式、接口和抽象类的使用中。它使得代码更加灵活、可扩展，并且能够更好地应对变化和需求的变动。
总之，多态性是面向对象编程中的重要概念，通过继承和方法重写实现，可以让程序更加灵活、可扩展，并提高代码的可维护性和可重用性。合理运用多态性的特性，可以写出更优雅、高效的代码。