1-11多态

多态简介

多态就是事物存在的多种形态，比如你在大街上看见一只藏獒，你可以说这只藏獒真凶猛，也可以说这只狗真凶猛，还可以说这个动物真凶猛，以上三种说法其实都是指的这只藏獒。
在Java里面，也是存在多态的，只要全部符合下面这三种情况，就是多态

有继承
有方法重写
有父类引用指向子类对象
例如下面代码就构成多态

定义一个Animal类

public class Animal{

    int num = 10;

    public void eat(){
        System.out.println("动物在吃！");
    }

}

定义一个Cat类继承Animal

public class Cat extends Animal{

    int num = 20;
    //重写
    public void eat(){
        System.out.println("猫吃猫粮");
    }

    //Cat特有的方法.
    public void move(){
        System.out.println("猫走路很轻盈！");
    }

}

定义一个Dog类继承Animal

public class Dog extends Animal{

    //重写
    public void eat(){
        System.out.println("狗啃骨头！");
    }
}

上面的三个类里面已经有继承和方法重写了，那么父类引用指向子类对象是什么？请看下面这段代码：
定义一个测试类

public class AnimalTest01{

    public static void main(String[] args){

        Cat c1 = new Cat();
        c1.eat();

        Animal a1 = new Cat();//父类引用指向子类对象
        a1.eat();
        System.out.println(a1.num);//因为成员变量不存在重写，所以结果是10
    }
}

静态绑定和动态绑定

上面代码中，a1是Animal类型的一个引用，指向的是其子类Cat的对象，这个就叫做父类引用指向子类对象。程序在编译的时候a1被看做Animal类型，所以a1.eat()绑定的是Animal类中的eat()方法，这叫做静态绑定，程序运行时，a1指向的是堆中的Cat对象，而在Cat中对eat()方法进行了重写，所以在运行阶段绑定的是Cat中的eat()方法，这叫做动态绑定。

强制类型转换

上面代码中子类向父类型进行转换，是自动类型转换，也叫做向上转型。还有一种情况是父类向子类型转换，是强制类型转换，也叫向下转型。下面的代码演示了强制类型转换

public class AnimalTest01{

    public static void main(String[] args){

        Animal a1 = new Cat();//父类引用指向子类对象
        //如果要是想执行Cat里面的move方法该怎么办？
        //只能强制类型转换,需要加强制类型转换符
        Cat c1 = (Cat)a1;
        c1.move();

        Animal a2 = new Dog(); //向上转型.
        //强制类型转换
        //Cat c2 = (Cat)a2; //会报错 java.lang.ClassCastException

    }
}

instanceof关键字

上面的代码里面将一个指向Dog对象的Animal引用a2进行强制转换成Cat类型时报出了ClassCastException类转型错误，开发中要是想避免这种错误需要使用instanceof来判断一下。

public class AnimalTest01{

    public static void main(String[] args){

        Animal a1 = new Cat();//父类引用指向子类对象
        //如果要是想执行Cat里面的move方法该怎么办？
        //只能强制类型转换,需要加强制类型转换符
        Cat c1 = (Cat)a1;
        c1.move();

        Animal a2 = new Dog(); //向上转型.
        //进行强制类型转换时，需要先使用instanceof进行判断，避免ClassCastException
        if(a2 instanceof Cat){
            //强制类型转换
            Cat c2 = (Cat)a2;
        }
    }    
}

多态的优点

提高了程序的扩展性
降低了代码之间的耦合
请看下面示例：
新建一个Car类

class Car{

    public void run(){

        System.out.println("汽车在跑");
    }
}

创建一个Benz类继承Car

class Benz extends Car{

    public void run(){

        System.out.println("奔驰汽车在跑");
    }
}

创建一个BMW类继承Car

class BMW extends Car {

    public void run(){

        System.out.println("宝马汽车在跑");
    }
}

创建一个Person类用来开车

class Person {
    /*
    public void drive(Benz bc){
        bc.run();
    }

奔驰汽车坏了，再重新创建一个开宝马汽车的方法

    public void drive(BMW bm){
        bm.run();
    }
    */

//上面代码扩展性太差，每新增加一种品牌的汽车就需要再写一个方法
//将参数修改为Car类型，这样不论增加什么样的品牌汽车，都可以调用这个方法

    public void drive(Car c){
        c.run();
    }
}

创建一个测试类

public class Test01 {
    public static void main(String[] args) {

        Person james = new Person();

        Benz bc = new Benz();
        james.drive(bc);

        BMW bm = new BMW();    
        james.drive(bm);


    }
}