前言：

本篇我们来解释一下什么是多态关系，多态关系属于面向对象三大特征的最后一个，可以说面向对象的重点就在多态，因此我们要学好面向对象编程思想，就要学好多态。

多态：

Java中的多态是指同一类对象在不同情况下可能表现出不同的形态和行为。它包括了方法重载和方法重写两种形式。

方法重载是指在同一个类中定义了两个或多个方法，它们的方法名相同，但参数类型、个数或顺序不同。当程序调用这个方法时，根据传入的参数类型自动匹配最合适的方法进行执行。

方法重写是指子类重写父类的某一个方法，方法名和参数列表都必须相同。当程序调用该方法时，会首先查找子类中是否存在该方法，如果存在则执行子类中的方法，如果不存在则会向上查找父类中是否有该方法，直到找到为止。

多态使得同一类对象可以表现出不同的行为，增强了程序的灵活性和扩展性，也是面向对象编程的基本特征之一。在Java中，多态实现通过继承、接口和抽象类等机制来实现。

多态的表现形式：

父类类型名称 =子类对象；

多态的前提：

有继承关系。
有父类引用指向子类对象。
有方法重写。

多态调用成员变量特点：

变量调用：编译看左边，运行看右边。
方法调用：编译看左边，运行看右边

package testo1;

public class test02 {
    public static void main(String[] args) {
        //利用多态创建对象。
        Animal a= new dog();
        //调用成员变量是编译看左边，运行看左边。
        System.out.println(a.name);
        //调用成员方法：
        //编译看左边，运行看右边。
       a.show();
    }

}
class Animal{
    String name ="动物";
    public void show()
    {
        System.out.println("animal-------show");
    }

}

class dog extends Animal{
    String name ="狗";
    @Override
    public void show ()
    {
        System.out.println("dog---------show");
    }

}
class cat extends Animal{
    String name ="狗";
    @Override
    public void show ()
    {
        System.out.println("cat---------show");
    }

}

运行结果：

在这个调用中我们可以发现：成员变量会随着建立对象的不同而不同。例如我们明明是Animal类型的对象，却打印了dog里面的方法。

如果子类对父类方法进行了重写，那么在虚方法表中是会对父类的方法进行覆盖的。

其实可以类比于C++里面的多态，感兴趣的同学可以点击这篇文章进行观看

C++ 动态多态实现底层逻辑_我是一盘牛肉的博客-CSDN博客

多态的优点：

1. 增强程序的灵活性：通过多态机制，同一个类型的不同对象可以表现出不同的行为。这使得程序的调用方式更加灵活，可以针对不同的对象调用不同的方法，无需为每一个具体对象都单独编写方法。

2. 提高代码的复用性：通过抽象类和接口，多态能够很好地实现代码的复用。在编写抽象类和接口时，我们可以定义一些通用的方法和属性，这些方法和属性可以被具体的子类继承和实现，从而减少代码的重复编写。

3. 提高程序的可扩展性：通过多态机制，在程序的运行过程中，可以动态地替换对象的行为。这使得程序的扩展性更加优秀，增加新的功能时，只需要添加新的类和方法即可，无需修改已有的代码。

4. 提高程序的可维护性：多态使得代码更加松散耦合，不同的类之间的关系更加清晰明了。这使得程序的维护性更好，对于模块性较强的程序，修改和维护的难度大大降低。

因此，多态在面向对象编程中具有重要的作用，能够提高程序的灵活性、可复用性、可扩展性和可维护性。

多态的缺点：

1. 程序执行效率略低：由于多态的实现需要动态绑定，即在运行时才能确定对象的类型和方法的执行地址，所以程序的执行效率会略微降低。

2. 代码可读性不高：由于多态性质的特殊性，程序中可能出现一个方法被多次重载、覆盖的情况，这样会使得代码的可读性变差，不容易理解。

3. 可能会造成误解或错误：由于父类无法完全限制子类的行为，所以在使用多态时，很容易陷入到某些无法预知的情况下，例如仅仅使用父类的属性而忽略了子类的某些特殊属性或方法，从而出现意外结果或错误。

虽然多态存在一些缺点，但是这些缺点可以通过适当的编码和测试来避免。在实际编程中，正确使用多态，在对程序的可维护性、可扩展性以及灵活性等方面都具有重要意义。

因为父类不可以调用子类的特有功能，因此例如我们在子类中的函数，如果我们的创建对象是父类，那么就无法使用这个方法，因此我们在JAVA中设置了转型

转型：

多态的转型是指通过类型转换，将一个对象在继承关系中沿着层次向上或向下进行类型转换，在转型过程中可以访问不同层次的方法和变量。

在Java中，类型转换分为向上转型和向下转型两种：

向上转型：将子类转换为父类对象，这种转换不需要进行特殊处理，自动完成向上转型。例如：Animal animal = new Cat()，Cat类是Animal类的子类，在这里就进行了向上转型。
向下转型：将父类对象转换为子类对象，需要强制类型转换才能实现。例如：Cat cat = (Cat) animal，在这里需要将Animal类型的对象进行强制类型转换为Cat对象，才能实现向下转型。

需要注意的是，在进行向下转型之前，必须进行向上转型，否则会报错。另外，在进行向下转型时，必须保证进行转换的对象是正确的类型，否则也会报错。

下面给出一个Java多态中的类型转换示例，通过向上转型和向下转型操作，来演示多态的转型过程：


interface Animal {
    public void eat();
}

class Cat implements Animal {
    public void eat() {
        System.out.println("Cat eat fish.");
    }

    public void meow() {
        System.out.println("Cat say meow.");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal = new Cat();
        animal.eat();

        Cat cat = (Cat) animal;
        cat.eat();
        cat.meow();
    }
}

在上述代码中，首先定义了一个接口 Animal，包含一个抽象方法 eat()。接着，定义一个实现了 Animal 接口的类 Cat，并且在 Cat 类中实现了 eat() 方法和 meow() 方法。在主方法中，创建了 Animal 类型的引用 animal，并将其设置为 Cat 类的实例。由于 Cat 类是 Animal 类的子类，因此可以进行向上转型。接着对 animal 调用 eat() 方法，输出“Cat eat fish.”。

接下来进行向下转型，在将 Animal 类型的引用 animal 转换为 Cat 类型的引用 cat。在向下转型后，可以调用 Cat 类特有的方法 meow()，输出“Cat say meow.”。

需要注意的是，在进行向下转型之前，必须进行向上转型。否则将会出现编译错误。同时，当进行向下转型时，必须进行类型检查，保证进行转换的对象是正确的类型。否则将会出现运行时错误。

总结：

多态更加丰富了子类与父类之间的关系网，更加完善了JAVA的功能，学好面向对象三大特征很重要，各位要熟练掌握这里的内容，才可以更加娴熟的使用JAVA。

如果我的内容对你有帮助，请点赞，评论，收藏。创作不易，大家的支持就是我坚持下去的动力！