Java基础--多态

一、概述：
什么是多态?
在 java 程序设计中，对象变量是多态的，多态是同一个行为具有多个不同表现形式或形态的能力。
也是 OOP （Object Oriented Programming）中的一个重要特性，主要是用来实现动态联编的，换句话说，就是程序的最终状态只由在执行过程中才被决定而非在编译期间就决定了。
这对于大型系统来说能提高系统的灵活性和扩展性。
多态是同一个行为具有多个不同表现形式或形态的能力。

二、多态实现的必要条件
使用手机扫描二维码支付时，二维码并不知道客户是通过何种方式进行支付，只有通过二维码后才能判断是走哪种支付方式执行对应流程。

/**
 * 支付类
 */
public  class Pay {
    public String pay(){
        return "success";
    }
}

/**
 *  支付宝
 */
class AliPay extends Pay {
    @Override
    public String pay() {
        System.out.println("支付宝支付成功");
        return super.pay();
    }
}

/**
 * 微信
 */
class WeixinPay extends Pay{
    @Override
    public String pay() {
        System.out.println("微信支付成功");
        return super.pay();
    }
}

/**
 * 银联
 */
class YinlianPay extends Pay{
    @Override
    public String pay() {
        System.out.println("银联支付成功");
        return super.pay();
    }
}

多态的使用形式：
父类 对象名 = new 子类（）；

测试：

public static void main(String[] args) {
    /**
     * 测试支付宝支付多态应用
     */
    Pay pay1 = new AliPay();
    pay1.pay();
    /**
     * 测试微信支付多态应用
     */
    Pay pay2 = new WeixinPay();
    pay2.pay();
    /**
     * 测试银联支付多态应用
     */
    Pay pay3 = new YinlianPay();
    pay3.pay();
}

实现多态的三个必要条件

1. 子类必须继承父类
2. 必须有重写
3. 向上转型：在多态中需要将子类的引用赋给父类对象，只有这样该引用才既能可以调用父类的方法，又能调用子类的方法。

多态的作用：
当我们想要改变某个方法的逻辑，又不想破坏原有的方法结构，那么可以利用多态，用子类重写一个方法

三.例题：

public class Test {
    public static void main(String[] args) {
        A a1 = new A();
        A a2 = new B();
        B b  =  new B();
        C c  =  new C();
        D d  =  new D();


        System.out.println("1---"+a1.Show(b));      //输出"A and A"
        System.out.println("2---"+a1.Show(c));      //输出"A and A"
        System.out.println("3---"+a1.Show(d));	 //输出"A and D"
//
        System.out.println("4----"+a2.Show(b));	 //输出"B and A"
        System.out.println("5----"+a2.Show(c));	 //输出"A and A"

        System.out.println("6----"+a2.Show(d));	 //输出"A and D"
//        
        System.out.println("7---"+b.Show(b));	 //输出"B and A"
        System.out.println("8---"+b.Show(c));	 //输出"B and A"
        System.out.println("9---"+b.Show(d));	 //输出"A and D"

    }
}

例题解析：
1.a1.Show(b)：

a1只能调用到自己的方法，即Show（D） 和 Show（A），因为B继承于A，b向上加载到类A，所以a1调用类A的Show（A）,即输出"A and A"； //2,3与1一样

3.a2.Show(b)：

a2可以调用的方法有类A的Show（D） 和 类B的Show（A），因为B继承于A，b向上加载到类A, 所以a2调用类B的Show（A），输出"B and A"； //5,6与3一样

7.b.Show(b)：

b能调用的方法时自身的Show（D） 和 Show（A）；因为B继承于A，b向上加载到类A，b调用类B的Show（A），输出"B and A" //8,9与7一样