多态

1.多态的概述

2.多态的格式与使用

代码当中体现多态性，其实就是一句话: 父类引用指向子类对象。
格式: 父类名称 对象名 = new子类名称();

或者: 接口名称对象名= new实现类名称();

父类

package cn.itcast.day10.demo01;

public class Fu {
    public void method(){
        System.out.println("父类方法");
    }

    public void methodFu(){
        System.out.println("父类特有方法");
    }
}

子类

package cn.itcast.day10.demo01;

public class Zi extends Fu {
    @Override //覆盖重写
    public void method() {
        System.out.println("子类方法");
    }
}

主函数

package cn.itcast.day10.demo01;

public class Multi {
    public static void main(String[] args) {
        //使用多态的写法
        //左侧父类的引用，指向了右侧子类的对象

        Fu obj = new Zi();
        obj.method();
        obj.methodFu();
    }
}

执行结果

子类方法
父类特有方法

3.多态中成员变量的使用特点

访问成员变量的两种方式:

1. 直接通过对象名称访问成员变量: 看等号左边是谁，优先用谁，没有则向上找。
2. 间接通过成员方法访问成员变量: 看该方法属于谁，优先用谁，没有则向上找。

父类

package cn.itcast.day10.demo02;

public class Fu {
    int num = 10;
    public void showNum(){
        System.out.println(num);
    }
}

子类

package cn.itcast.day10.demo02;

public class Zi extends Fu {
    int num = 20;

    @Override
    public void showNum() {
        System.out.println(num);
    }
}

主函数

package cn.itcast.day10.demo02;

public class multiField {
    public static void main(String[] args) {
        //使用多态的写法，父类引用指向子类对象
        Fu a = new Zi();
        System.out.println(a.num);
       //子类没有覆盖重写，就是父: 10

       //子类如果覆盖重写，就是子: 20
       a.showNum();
    }
}

执行结果

10
20

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

在多态的代码当中，成员方法的访问规则是:看new的是谁，就优先用谁，没有则向上找。
对比一下:
成员变量:编译看左边，运行还看左边。
成员方法:编译看左边，运行看右边。|
父类：

package cn.itcast.day10.demo02;

public class Fu01 {
    public void method(){
        System.out.println("父类方法");
    }

    public void methodFu(){
        System.out.println("父类特有的方法");
    }
}

子类

package cn.itcast.day10.demo02;

public class Zi01 extends Fu01{
    @Override
    public void method() {
        System.out.println("子类方法");
    }

    public void methodZi(){
        System.out.println("子类特有方法");
    }
}

主函数

package cn.itcast.day10.demo02;

public class multiMethod {
    public static void main(String[] args) {
        Fu01 obj = new Zi01(); //多态
        obj.method();    //父子都有，优先用子
        obj.methodFu();  // 子类没有父类有，向上找到父类
    }
}

执行结果

子类方法
父类特有的方法

5.多态的好处

5.对象的向上转型

对象的向上转型，就是父类引用指向子类对象。

Animal类

package cn.itcast.day10.demo02;

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

Cat类——继承Animal

package cn.itcast.day10.demo02;

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

主函数

package cn.itcast.day10.demo02;

public class AnimalCat {
    public static void main(String[] args) {
        //对象的向上转型，就是父类引用指向子类对象。
        Animal animal = new Cat();
        animal.eat();
    }
}

执行结果`

猫吃鱼

6.对象的向下转型

向上转型一定是安全的，没有问题的，正确的。但是也有一个弊端: 对象一旦向上转型为父类，那么就无法调用子类原本特有的内容。

注意事项:
a.必须保证对象本来创建的时候，就是猫，才能向下转型成为猫。
b.如果对象创建的时候本来不是猫，现在非要向下转型成为猫，就会报错。ClassCastException
类似于:
int num = (int) 10.0; //可以
int num = (int) 10.5; //不可以，精度损失

package cn.itcast.day10.demo02;

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

package cn.itcast.day10.demo02;

public class AnimalCat {
    public static void main(String[] args) {
        //对象的向上转型，就是父类引用指向子类对象。
        Animal animal = new Cat();
        animal.eat();

        //向下转型，进行还原动作
        Cat cat = (Cat)  animal;
        cat.catchMouse();
    }
}

执行结果

猫吃鱼
猫抓老鼠

7.接口与多态的综合案例

7.1笔记本电脑
笔记本电脑(laptop) 通常具备使用USB设备的功能。在生产，笔记本都预留了可以插入USB设备的USB接口,但具体是什么USB设备，笔记本厂商并不关心，只要符合USB规格的设备都可以。
定义USB接口，具备最基本的开启功能和关闭功能。鼠标和键盘要想能在电脑上使用，那么鼠标和键盘也必须遵守USB规范，实现USB接口，否则鼠标和键盘的生产出来也无法使用。
7.2 案例分析
进行描述笔记本类，实现笔记本使用USB鼠标、USB键盘

1. USB接口，包含打开设备功能、关闭设备功能
2. 笔记本类，包含开机功能、关机功能、使用USB设备功能
3. 鼠标类，要实现USB接口，并具备点击的方法
4. 键盘类要实现USB接口，具备敲击的方
   

Usb接口

package cn.itcast.day10.demo03;

public interface Usb {
    public abstract void open(); //打开设备
    public abstract void close();  //关闭设备
}

鼠标类

package cn.itcast.day10.demo03;

//鼠标就是一个USB设备
public class Mouse implements Usb {
    @Override
    public void open() {
        System.out.println("打开鼠标");

    }

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

    public void click(){
        System.out.println("鼠标点击");
    }
}

键盘类

package cn.itcast.day10.demo03;

//键盘就是一个USB设备
public class Keyboard implements Usb {
    @Override
    public void open() {
        System.out.println("打开键盘");

    }

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

    public void type(){
        System.out.println("键盘输入");

    }
}

电脑类

package cn.itcast.day10.demo03;

import java.security.Key;

public class Computer {
    public void powerOn(){
        System.out.println("笔记本电脑开机");
    }
    public void powerOff(){
        System.out.println("笔记本电脑关机");
    }
//使用USB设备的方法，使用接口作为方法的参数
    public void useDevice(Usb usb){
        usb.open();  //打开设备
        if(usb instanceof Mouse){  //一定要先判断
            Mouse mouse = (Mouse) usb;
            mouse.click();              //向下转型
        }
        else if(usb instanceof Keyboard){
            Keyboard keyboard = (Keyboard) usb;
            keyboard.type();              //向下转型
        }
        usb.close(); //关闭设备
    }
}

主函数

package cn.itcast.day10.demo03;

public class ComputerMain {
    public static void main(String[] args) {
         // 首先创建一个笔记本电脑
        Computer computer = new Computer();
        computer.powerOn();

        //准备一个鼠标，供电脑使用
        //首先进行向上转型
        Usb usbMouse = new Mouse(); //多态写法
        //参数是Usb类型，正好传递进去的就是usb鼠标
        computer.useDevice(usbMouse);

        //创建一个USB键盘
        Keyboard keyboard = new Keyboard(); //没有使用多态写法
        //方法参数是USB类型，传递进去的是实现类对象
        computer.useDevice(keyboard);  //正确写法，也发生了向上转型
        //computer.useDevice(new Keyboard()); //也是正确写法

        computer.powerOff();
    }
}

执行结果

笔记本电脑开机
打开鼠标
鼠标点击
关闭鼠标
打开键盘
键盘输入
关闭键盘
笔记本电脑关机