Java学习笔记——多态

一、概述

• 引入
  多态是封装、继承之后，面向对象的第三大特性。

生活中，比如跑的动作，小猫、小狗和大象，跑起来不一样的。
再比如飞的动作，昆虫、鸟类和飞机，飞起来也不一样的。

可以说同一行为，通过不同的事物，可以体现出来的不同的形态。多态，描述的就是这样的状态。

• 定义
• 多态：是指同一行为，具有多个不同的表现形式。

二、多态的体现

多态的体现的格式

父类类型  变量名  =  new 子类对象；
变量名.方法名();

父类类型：指子类对象继承的父类类型，或者实现的父接口类型。

代码如下

 Fu f = new Zi();
 f.method

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译报错；如果有，执行的是子类重写后方法。

代码如下
定义父类

public abstract class Animal {
    public abstract void eat();
}

定义子类

public class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("吃鱼");
    }
}

public class Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("吃骨头");
    }
}

测试类

public class test02 {
    public static void main(String[] args) {
        //多态形式，创建对象
        Animal a1 = new Cat();
        //调用的是Cat的eat
        a1.eat();

        //多态形式，创建对象
        Animal a2 = new Dog();
        //调用的是Dog的eat
        a2.eat();

    }
}

运行结果

三、多态好处

父类类型作为方法形式参数，传递子类对象给方法，进行方法的调用，更能体现出多态的扩展性与便利。

代码如下

定义父类

public abstract class Animal {
    public abstract void eat();
}

定义子类

public class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("吃鱼");
    }
}

public class Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("吃骨头");
    }
}

测试类

public class test03 {
    public static void main(String[] args) {
        //多态形式，创建对象
        Cat c = new Cat();
        Dog d = new Dog();

        //调用showCatEat
        showCatEat(c);
        //调用showDogEat
        showDogEat(d);

        /**
         * 以上两个方法，均可以被showAnimalEat(Animal a)方法所替代
         * 而执行效果一致
         */
        showAnimalEat(c);
        showAnimalEat(d);

    }

    public static void showCatEat(Cat c){
        c.eat();
    }

    public static void showDogEat(Dog d){
        d.eat();
    }

    public static void showAnimalEat(Animal a){
        a.eat();
    }
}

运行结果
由于多态特性的方法，showAnimalEat方法的Anmal类型，是Cat和Dog的父类类型，父类类型接收子类对象，当然可以吧Car对象和Dog对象，传递给方法。

当eat方法执行时，多态规定，执行的是子类重写得到方法，那么效果自然与showCatEat和showDogEat方法一致，所以showAnimalEat完全可以替代以上两个方法。

不仅仅是替代，在扩展性方面，无论之后再多的子类出现，我们不需要编写showXxxEat方法，直接使用showAnimalEat都可以完成。

所以，多态的好处，可以使编程序编写的更简单，并有良好的扩展。

四、引用类型转换

多态的转型分为向上转型与向下转型两种：

向上转型

• 向上转型：多态本身是子类类型向父类类型向上转换的过程，这个过程是默认的。

当父类引用指向一个子类对象时，便是向上转型。

使用格式

父类类型  变量名  =  new 子类类型();
如：Animal a  =  new Cat();

向下转型

• 向下转型：父类类型向子类类型向下转换的过程，这个过程是强制的。

一个已经向上转型的子类对象，将父类引用转为子类引用，可以使用强制类型转换的格式，便是向下转型。

使用格式

子类类型  变量名  =(子类类型)父类变量名;
如:Cat c=(Cat) a;

为什么要转型

当使用多态方式调用方法时，首先检查父类中是否该有方法，如果没有，则编译错误，也就是说，不能调用子类拥有，而父类没有的方法。编译报错，更别说运行，这也是多态给我们带来小麻烦，所以，想要调用子类特有的方法，必须做向下转型。

转型演示，代码如下

定义类

public abstract class Animal {
    abstract void eat();
}

public class Cat extends Animal{
    @Override
    void eat() {
        System.out.println("吃鱼");
    }
    public void catchMouse(){
        System.out.println("抓老鼠");
    }
}

public class Dog extends Animal{
    @Override
    void eat() {
        System.out.println("吃骨头");
    }
    public void watchHouse(){
        System.out.println("看门狗");
    }
}

测试类

public class test {
    public static void main(String[] args) {
        //向上转型
        Animal a = new Cat();
        a.eat();    //调用的是Cat 的 eat

        //向下转型
        Cat c = (Cat)a;
        c.catchMouse(); //调用的是Cat 的catchMouse
    }
}

运行结果

转型异常

测试类

public class test02 {
    public static void main(String[] args) {
        //向上转型
        Animal a = new Cat();
        a.eat(); //调用的是Cat 的 eat

        //向下转型
        Dog d =(Dog)a;
        d.watchHouse();  //调用的是Dog 的 watchHouse运行报错
    }
}

运行结果

这段代码可以通过编译，但是运行时，却报出了 ClassCastException ，类型转换异常！这是因为，明明创建了Cat类型对象，运行时，当然不能转换成Dog对象的。这两个类型并没有任何继承关系，不符合类型转换的定义。

为了避免ClassCastException的发生，Java提供了instanceof关键字，给引用变量做类型的校验，格式如下：

变量名  instanceof  数据类型
如果变量属于该数据类型，返回true，
如果变量不属于该数据类型，返回false。

所以，转换前，最好做一个判断，代码如下：

 public static void main(String[] args) {
        //向上转型
        Animal a = new Dog();
        a.eat(); //调用的是Cat 的 eat

        //向下转型
        if(a instanceof Cat){
            Cat c = (Cat)a;
            c.catchMouse();
        }else if(a instanceof Dog){
            Dog d =(Dog)a;
            d.watchHouse();
        }
    }

运行结果