Java多态的简单理解

多态：是指同一行为具有多个不同表现形式。

前提条件：

继承或者实现【二选一】
方法的重写【意义体现：不重写，无意义】
父类引用指向子类对象【格式体现】父类对象名 = new 子类对象（）

多态的体现格式：

父类类型 变量名 = new 子类对象；
变量名.方法名（）；

代码如下：

Fu f = new Zi();
f.method();

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

代码如下：

定义父类：

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

定义子类：

class Cat extends Animal{
    public void eat(){
        System.out.println("吃鱼“）；
    }
}

class Dog extends Animal{
    public void eat(){
        System.out.println("吃骨头“）；
    }
}

定义测试类：

public class Test{
    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 Cat extends Animal{
    public void eat(){
        System.out.println("吃鱼“）；
    }
}

public Dog extends Animal{
    public void eat(){
        System.out.println("吃骨头“）；
    }
}

定义测试类：

public class Test{
    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(Dof d){
        d.eat();
    }
    public static void showAnimalEat(Animal a){
        a.eat();
    }
}

由于多态特性的支持，showAnimalEat方法的Animal类型，是Cat和Dog的父类类型，Cat和Dog的父类类型，父类类型接收子类对象，当然可以把Cat对象和Dog对象，传递给方法。

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

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

所以，多态的好处体现在可以使编程更简洁，并有良好的扩展。

引用类型转换

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

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

使用格式：

父类类型 变量名 = new 子类类型（）；
如：Animal a = new Cat（）；

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

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

使用格式：

子类类型 变量名 = （子类类型） 父类变量名；
如：Cat c = （Cat） a；

为什么要转型？

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

转型演示，代码如下：

定义类：

abstract class Animal{
    abstract void eat();
}

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

class Dog extends Animal{
    public 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

转型的异常

转型过程中，一不下心就会遇到这样的问题，代码如下：

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

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

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

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

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

所以转换前，我们最好做一个判断：

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

        //向下转型
        if(a instanceof Cat){
            Cat c = (Cat)a;
            c.catchMouse();//调用的是Cat的catchMouse
        }else if（a instanceof Dog）{
            Dog d = （Dog）a;
            //调用的是Dog的watchHouse
        }
    }
}

案例需求

定义笔记本类，具备开机，关机和使用 USB 设备的功能。具体是什么 USB 设备，笔记本并不关心，只要符合 USB 规

格的设备都可以。鼠标和键盘要想能在电脑上使用，那么鼠标和键盘也必须遵守 USB 规范，不然鼠标和键盘插在电

脑上无法使用 ;

需求 : 进行描述笔记本类，实现笔记本使用 USB 鼠标、 USB 键盘

USB 接口，包含开启功能、关闭功能

笔记本类，包含运行功能、关机功能、使用 USB 设备功能

鼠标类，要符合 USB 接口

键盘类，要符合 USB 接口

代码如下：

//定义鼠标、键盘、笔记本三者之间应该遵守的规则
public interface USB{
    void open();//开启功能
    voidclose();//关闭功能
}

//鼠标实现USB规则
public class Mouse implements USB{
    public void open(){
        System.out.println("鼠标开启");
    }
    public void close(){
        System.out.println("键盘关闭");
    }
}
//键盘实现USB规则
public class keyBoard implemenets USB{
    public void open(){
        System.out.println("键盘开启");
    }
    public void close(){
        System.out.println("键盘关闭");
    }
}

//定义笔记本
public class NoteBook{
    //笔记本开启运行功能
    public void run(){
        System.out.println("笔记本运行");
    }
    //笔记本使用USB设备，这时当笔记本对象调用这个功能时，必须给其传递一个符合USB规则的USB设备
    public void useUSB(USB usb){
        //判断是否有ＵＳＢ设备
        if(usb!=null){
            usb.open();
            usb.close();
        }
    }
    public void shutDown(){
        System.out.println("笔记本关闭");
    }
}

//测试
public class Test{
    public static void main(String[] args){
        //创建笔记本实体对象
        NoteBook nb = new BoteBook();
        //笔记本开启
        nb.run();
        //创建鼠标实体对象
        Mouse m = new Mouse();
        //笔记本使用鼠标
        nb.usbUSB(m);
        //创建键盘实体对象
        KeyBoard kb = new KeyBoard();
        //笔记版使用键盘
        nb.usbUSB(kb);
        //笔记本关闭
        nb.shutDown();
    }
}