多态性理解

了解一个东西，可以先了解它用来干嘛，这样理解它的具体实现、应用场景就事半功倍！

那么，多态用来干嘛呢？

一、什么是多态

举个例子：

同样一个快捷键（引用类型），在不同的窗口（指向的对象类型）如word文档，浏览器界面，可能有不同的功能（调用的方法）。

也就是说：

同一方法可以根据发送对象的不同而采用多种不同的行为方式。

二、具体实现/多态条件

1.继承:

增添一个又一个功能，修改一次又一次，逻辑乱了怎么办？

所以采用派生类，每个类去实现新功能，就不用修改原有代码（父类）。

2.重写:

增添新功能，或者说不要父类的功能，当然需要去重写方法咯。

3.向上转型:

这个是为了简洁代码！！！

这个是为了简洁代码！！！

这个是为了简洁代码！！！

 

场景：

方法传参使用多态（最常见）：形参为父类对象，实参可以是父类对象也可以是子类对象，甚至是对象数组。

方法返回值用多态：方法返回值类型是父类类型，return值可以是父类对象、也可以是子类对象。

 

不使用向上转型，要调用子类的方法，需要创建各自的对象（出现多个变量）：

//一个个实例化

S1 s1 = new S1();
S2 s2 = new S2();
S3 s3 = new S3();

//各自调用重写后的方法

s1.method();
s2.method();
s3.method();

如果使用向上转型呢？

......

好吧，我想不出能跟上面类比的形式，但这里有一个【多收入税收案例】运用到了多态，该案例出自廖雪峰。

派生并重写：

//普通收入税收
class Incom{
    protected double income;
    public Incom(double income) {
        this.income = income;
    }
    public double getTax() {
        return 0.1*income;  //税率10%
    }
}

//工资收入税收：阶梯税收
class AIncom extends Incom{
    public AIncom(double income) {
        super(income);
    }
    @Override
    public double getTax() {
        if (income <= 5000){
            return 0;
        }else{
            return (income-5000)*0.2;
        }
    }
}

//特殊津贴：无税
class BIncom extends Incom{
    public BIncom(double income) {
        super(income);
    }

    @Override
    public double getTax() {
        return 0;
    }
}

转型：

/*多态联系_税收案例
    多收入税收
*/
public class Revenue {

    //总的税收计算
    public static  double getRevenue(Incom ...incoms){  //传入可变长对象类型
        double total = 0;
        for (Incom incom : incoms) {    //向上转型
            total = total + incom.getTax(); //多态性，调用各自的重写方法
        }
        return total;
    }

    //主方法
    public static void main(String[] args) {
        //创建对象数组
        Incom[] incoms = {
                new Incom(3000),
                new AIncom(7500),
                new BIncom(15000)
        };
        System.out.println(getRevenue(incoms));//对象数组传进计算方法
    }
}

可以看到，在调用计算方法那里，代码很简洁......

 

如果我们要新增一种稿费收入，只需要从Incom派生，然后正确覆写getTax()方法就可以。把新的类型传入totalTax()，不需要修改任何代码。

可见，多态具有一个非常强大的功能，就是允许添加更多类型的子类实现功能扩展，却不需要修改基于父类的代码。