01. 多态的概述
 什么是多态?

    一个对象，在不同的时刻有着不同的形态，

举个例子：

    设定一个抽象的people为父类，Teacher，worker，student都继承people，即为people的子类。

    people（人类）在学校里为身份为student（学生）或者Teacher（教师），在工地上身份可以

是worker（工人），而学生、教师、工人等这些人归根结底都是人类，即学生、教师、工人不同的状态可以理解为people的多态，而每个不同的子类所特有的成员方法就是多态的表现。这就是多态。
 

02. 多态的格式与使用
多态的前提是?

    总结:
        1.多态使用的前提
            必须是有继承或者是接口实现类才有多态
            必须有重写方法[不一定]
            父类指向子类对象的引用
            父  对象名  =  new Zi();

        2.多态的格式?
            普通类的多态
                父类  对象名  = new 子类();
            抽象类的多态
                抽象类  对象名  = new 抽象类的子类();
            接口类的多态
                接口名 对象名 = new 接口实现类对象();

03. 多态中成员方法的使用特点

多态中成员方法的访问提点?

    总结:

        =左边是谁，用的就是谁。如果子类重写了父类中的方法，在执行的时候，执行的是子类的

        口诀: 
            编译看左边【父类/接口】，运行看右边【子类/实现类】

04. 使用多态的好处和弊端
无论右边new的是那个子类对象, 左边都不会发生变化

    总结:
        * 使用多态有什么好处?
            提高代码的扩展性，左边的类型始终都不变，变的是具体创建子类对象
        * 使用多态有什么弊端?
            使用不了子类特有的成员
         

05. 对象的向上转型

什么是多态的向上转型?

例：

Animal  animal=new Dog（）；

父类（动物类）指向子类（狗类）

可以理解为狗是动物，我们以动物来代称狗

    总结:

        格式：
            父类类型  对象名  =  new  子类();

        安全问题:
            没有安全问题，放心大胆使用！！！！

06. 对象的向下转型
为什么要向下转型?

//抽象的动物类
public abstract class Animal {
    public abstract void eat();

}
//继承动物类的狗类

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

    }
//狗特有的行为
 public void LookHome() {
        System.out.println("~~狗特有的行为：看家~~");

    }




}

//继承动物类的猫类
public class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("~~猫吃鱼~~");

    }
//猫特有的行为
 public void catche() {
        System.out.println("~~猫特有的行为：捉老鼠~~");

    }

}

//以下是测试类编写
public class Test {
//该方法用来输出相关动物的行为
    public static void showAction(Animal animal){
        if (animal instanceof Cat){//instanceof判断当前动物类是否可以作为子类cat
            Cat c=(Cat)animal; //向下转型
            c.eat();
            c.catche();
        }else if (animal instanceof Dog)
        {
            Dog d=(Dog) animal; //向下转型
            d.eat();
            d.LookHome();
        }
    }
    public static void main(String[] args) {
       //向上转型
       Animal  animal01=new Dog（）；
       Animal  animal02=new Cat（）；
       //向下转型
       //Dog dog=（Dog）animal01；
       //Cat cat=（Cat）animal02；
       showAction(animal01);
       showAction(animal02);

    }



}

向下转型其实就是强制转换。

可以理解为狗是动物，我们用动物来代称狗或者猫，猫和狗都有自己特有的行为，我们在调用动物时的行为方法时，不同的动物会有不同的行为，例如猫会捉鼠，狗会看家等。。。。。。。具体可以结合练习题理解

    总结:

        1.什么情况下需要用到向下转型?
            只有用到了子类特有的行为时，才向下转型
            
        2.向下转型的格式
            基本数据类型强制类型转换: 目标数据类型  变量名  = (目标数据类型)需要转换的数据
            引用数据类型强制类型转换: 子类类名 对象名 = (子类类名)父类对象名;
     注意事项: 要想使用多态的向下转型，必须前提有多态的向上转型

          
07. 用instanceof关键字进行类型判断
 instanceof 关键字的作用是什么?

    instanceof 关键字用来判断当前类的类型是否可以作为子类使用。

//格式:
父类对象名  instanceof 子类类型（类名）
        判断父类对象，是否能当作某一个子类型来使用


// 使用格式 :
 
if (父类对象名 instanceof 子类类型) {
            多态的向下转型
        }

    
 

关于多态的练习题：

1.手机

根据需求完成代码:
    (1)定义一个手机类
        a.行为:打电话,发短信
    (2)定义一个接口IPlay
        a.行为:玩游戏

    (3)定义一个旧手机类继承手机类
        a.行为:继承父类的行为

    (4)定义一个新手机继承手机类实现IPlay接口
        a.行为:继承父类的行为,重写玩游戏方法

    (5)定义一个测试类
        a.在测试类中定义一个 用手机的方法,要求该方法既能接收老手机对象,也能接收新手机对象
            在该方法内部调用打电话,发短信以及新手机特有的玩游戏方法。

接口：

public interface IPlay {
    public void playGame();
}

定义抽象的手机类：

public class Phone {

    public  void call(){
        System.out.println("~~打电话~~");
    }
    public void sendEml(){
        System.out.println("~~发短信~~");
    }
}

旧手机和新手机继承手机类，都拥有打电话和发短信的功能，而新手机可以玩游戏所以实现接口IPlay

//旧手机继承手机类
public class OldPhone extends Phone {

}

//新手机继承手机类，并实现玩游戏的接口
public class NewPhone extends Phone implements IPlay{
    @Override
    public void playGame() {
        System.out.println("~~~玩游戏~~~");
    }
}

测试：

package homework2;

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

        NewPhone n=new NewPhone();
        OldPhone o=new OldPhone();
        usePhone(o);
        usePhone(n);
    }

    public static void usePhone(Phone p) {
        p.call();
        p.sendEml();
    if (p instanceof NewPhone)
       {
           NewPhone n=(NewPhone)p;
           n.playGame();
       }
    }
}

2.进行描述笔记本类，实现笔记本使用USB鼠标(Mouse)、USB键盘(Keyboard)
     (1) a.USB接口:
            开启功能
            关闭功能
        b.笔记本类:
            开机功能
            关机功能
        c.笔记本中定义使用USB设备的功能 接口作为方法的参数和返回值
           要求:既能使用鼠标也能使用键盘,使用USB功能内部调用开启和关闭功能
    (3)鼠标类(Mouse):
        要符合USB接口
    (4)键盘类(KeyBoard):
        要符合USB接口
    (5)测试类:
        创建电脑对象,依次调用开机方法,使用USB设备, 关机方法
    (6)打印效果如下:
        开机
        连接鼠标的USB
        断开鼠标的USB
        连接键盘的USB
        断开键盘的USB
        关机

//usb接口

public interface USB {
    public void open();
    public void close();

}

鼠标和键盘实现USB接口：

//鼠标类实现usb接口
public class Mouse implements USB {
    @Override
    public void open() {
        System.out.println("鼠标usb接口打开");
    }

    @Override
    public void close() {
        System.out.println("鼠标usb接口关闭");
    }
}


//键盘类实现usb接口
public class KeyBoard implements USB{
    @Override
    public void open() {
        System.out.println("键盘usb接口打开");
    }

    @Override
    public void close() {
        System.out.println("键盘usb接口关闭");
    }
}

电脑类实现相关方法：

public class Computer {
    public void ComputerOpen(){
        System.out.println("~~电脑启动~~");
    }
    public void ComputerClose(){
        System.out.println("~~电脑关机~~");
    }
    public void useUSB(USB u){
            // 判断是否是鼠标
            if (u instanceof Mouse) {
                // 鼠标点击
                Mouse m = (Mouse) u;
                m.open();
            }
            if (u instanceof KeyBoard) {
                KeyBoard k = (KeyBoard) u;
                k.open();
            }
        }
    public void CloseUSB(USB u){
        if (u instanceof Mouse) {
            Mouse m = (Mouse) u;
            m.close();
        }
        if (u instanceof KeyBoard) {
            KeyBoard k = (KeyBoard) u;
            k.close();
        }
    }


}

通过测试类调用测试多态

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

        Computer computer=new Computer();
        KeyBoard k=new KeyBoard();
        Mouse m=new Mouse();
        computer.ComputerOpen();//启动电脑
        computer.useUSB(k);//启动键盘接口
        computer.useUSB(m);//启动鼠标接口
        computer.CloseUSB(k);//关闭键盘接口
        computer.CloseUSB(m);//关闭鼠标接口
        computer.ComputerClose();//关机
    }
}

3.老司机开车案例.
    1.定义一个汽车类Car.有一个抽象方法run().
    2.定义一个小客车BabyCar类继承Car类;
    3.定义一个公交车类Bus继承Car类
    4.在测试类中定义一个方法.//把Xxx修改成具体类型.
    public static void dirverCar(Xxx x){
        x.run();
    }
    调用dirverCar方法.要求任何一种类型的车都可以开起来.

抽象类：car

public class Bus extends Car{
    @Override
    public void run() {
        System.out.println("Bus启动");
    }
}

实体类：Bus和Babycar

//bus类继承car
public class Bus extends Car{
    @Override
    public void run() {
        System.out.println("Bus启动");
    }
}

//Babycar类继承car
public class Babycar extends Car{
    @Override
    public void run() {
        System.out.println("Babycar启动");

    }
}

测试类

public class test {
    public static void dirverCar(Car c){
        c.run();
/*
之所以用直接用run就能调用形参中的Car c是因为，对于如果访问父子类中的共有方法时，优先访问子类重写的方法，这是继承的特点。
*/
    }

    public static void main(String[] args) {
        Car bus=new Bus();
        Car babycar=new Babycar();
        dirverCar(bus);
        dirverCar(babycar);
    }
}