目录

1、认识多态       

2、多态的好处和存在的问题

2.1使用多态的好处

2.2多态存在的问题

3、多态下的类型转换

4、综合案例—支付模块

---

1、认识多态       

         多态是在继承/实现下的一种现象，表现为：对象多态，行为多态。

对象多态

• 对象多态是面向对象编程中的重要概念，允许父类引用指向子类对象。
• 语法形式：Animal a1 = new Wolf()；例如下面代码就是对象多态。

行为多态

• 行为多态是面向对象编程中的核心概念，指的是同一个方法调用在不同对象上表现出不同的行为。

Animal 类

public class Animal {
    String name = "动物";
    public void run(){
        System.out.println("动物会跑~~~");
    }
}

Wolf 类

public class Wolf extends Animal{
    String name = "狼";
    @Override
    public void run(){
        System.out.println("狼跑的贼快~~~");
    }
}

Tortoise 类

public class Tortoise extends Animal {
    String name = "乌龟";

    @Override
    public void run(){
        System.out.println("乌龟跑得慢");
    }
}

Test类：测试类

public class Test {
    public static void main(String[] args) {
        //1、对象多态，行为多态
        Animal a1 = new Wolf();
        Animal a2 = new Tortoise();
        a1.run();//编译看左边，运行看右边。编译看Animal运行看 Wolf
        a2.run();//编译看左边，运行看右边
        System.out.println(a1.name);//成员变量，编译看左边，运行看左边
        System.out.println(a2.name);//成员变量，编译看左边，运行看左边
    }
}
/*
输出结果：
狼跑的贼快~~~
乌龟跑得慢
动物
动物
 */

2、多态的好处和存在的问题

2.1使用多态的好处

• 好处1：在多态形式下，右边对象是解耦合的，更便于扩展和维护。

        解耦合的概念：解耦合是指降低软件组件之间的依赖关系，使各个模块尽可能独立，减少相互影响

• 好处2：定义方法时：使用父类类型的形参，可以接收一切子类对象、扩展性强更便利。

2.2多态存在的问题

• 多态下不能使用子类的独立功能。

3、多态下的类型转换

        上面提到在多态下不能使用子类的独立功能，那么怎么解决这个问题呢？使用多态的强制类型转换。

Animal 类

public class Animal {
    String name = "动物";
    public void run(){
        System.out.println("动物会跑~~~");
    }
}

Tortoise 类

public class Tortoise extends Animal {
    String name = "乌龟";

    @Override
    public void run(){
        System.out.println("乌龟跑得慢");
    }
}

Wolf 类

public class Wolf extends Animal{
    String name = "狼";
    @Override
    public void run(){
        System.out.println("狼跑的贼快~~~");
    }
    //这里是子类狼的独有功能
    public void eat(){
        System.out.println("狼吃羊~~~");
    }
}

Test类：测试类

public class Test {
    public static void main(String[] args) {
        //1、对象多态，行为多态
        Animal a1 = new Wolf();  //狼
        Animal a2 = new Tortoise();
        a1.run();//编译看左边，运行看右边。编译看Animal运行看 Wolf
        a2.run();//编译看左边，运行看右边
        System.out.println(a1.name);//成员变量，编译看左边，运行看左边
        System.out.println(a2.name);//成员变量，编译看左边，运行看左边

        print(a1);
    }
    public static void print(Animal a){  //这里形参传入方式是多太多的第二个好处。
        //如果在这里直接调用子类狼的独有的方法/行为
        //a.eat();  //报错
        //解决上面调用多态调用子类独立方法报错的问题：
        //强制类型转换，但是要注意的是，强制类型转换可能会出错，如果把不是狼的对象转换成狼对象，就会出错
        //所以一般多态强制类型转换的时候会加关键字 "instanceof"做判断
        System.out.println("----开始------");
        if(a instanceof Wolf){
            Wolf w = (Wolf)a;
            w.eat();
        } else if (a instanceof Tortoise) {
            Tortoise t = (Tortoise)a;
        }
    }
}

/*
输出结果：
狼跑的贼快~~~
乌龟跑得慢
动物
动物
----开始------
狼吃羊~~~
 */

4、综合案例—支付模块