三大特征-多态性

多态性：在程序中，一个引用变量可以指向多种实际类型

继承性是多态性的前提，多态性允许不同的对象对同一个消息做出不同的响应

一、多态分类

1、编译时多态（静态多态）

• 方法重载

  基于传入参数的数量和类型，在编译时就可以确定调用哪个方法

  操作名称的多态，多个操作具有相同的名字，所接收的消息类型必须不同

2、运行时多态（动态多态）

• 方法重写

  在运行时才能确定调用哪个类（子类还是父类）的方法实现

  继承有关的多态，同一个操作被不同类型对象调用时可能产生不同的行为

• 接口实现

  当一个类实现一个接口时，该类必须提供接口中所有抽象方法的具体实现

  接口引用指向实现类对象，调用接口中的方法时，会执行该类中的方法实现

上下转型

对象的上下转型：将一个对象的引用从一种类型转换为另一种类型

这些转换通常发生在继承体系中，涉及父类（或接口）和子类之间的引用转换

• 向上转型（Upcasting）

  • 向上转型是将子类对象的引用转换为父类（或接口）类型的引用

  • 向上转型一定是安全的，因为子类对象可以被当作父类对象使用（老虎是动物，成立）
    ​
    根据里氏替换原则，子类必须能够替换其父类，所以父类引用指向子类对象是完全合法的

• 向下转型（Downcasting）

  • 向下转型是将父类（或接口）类型的引用转换为子类类型的引用

  • 向下转型可能是不安全的，因为父类引用可能并不指向一个子类对象

    在进行向下转型之前，需要使用instanceof运算符来检查对象是否是目标子类的实例

// 动物类
public class Animal {
    public void eat(){
        System.out.println("animal eat...");
    }
    
    public void sleep(){
        System.out.println("animal sleep...");
    }
}

// 老虎类
public class Tiger extends Animal {
    @Override
    public void eat() {
        System.out.println("tiger eat...");
    }
}

// 测试类
public class Test {
    public static void main(String[] args) {
        // 不安全的向下转型
		Animal animal = new Animal();  
        // Tiger tiger = (Tiger) animal; // 抛出 ClassCastException
                
        // 安全的向下转型   
        if (animal instanceof Tiger) {  
            Tiger safeTiger = (Tiger) animal;  
        } 
        
        // 向上转型一定是安全的
		animal = new Tiger();
    }
}

当说老虎是动物时，老虎将失掉老虎独有的属性和功能

从人的思维方式上看，“老虎是动物” 属于上溯思维方式（上转型对象）

• 上转型对象，失去子类【特有】的属性和功能
• 下转型对象，具备子类【所有】的属性和功能，含从父类继承的变量和方法

        Animal animal = new Tiger(); 
        if (animal instanceof Tiger) {  
            Tiger tiger = (Tiger) animal; // 向下转型 
            tiger.sleep(); // 从父类继承的方法，正常执行
        } 

• 上转型对象不能操作子类新增的成员变量，不能调用子类新增的成员方法
• 上转型对象操作子类继承或隐藏的成员变量，调用子类继承或重写的实例方法

// 父类
public class Fu {
    int numFu = 10;
    int num = 20;

    public void methodFu() {
        System.out.println("methodFu...");
    }

    public void method() {
        System.out.println("method in Fu...");
    }
    
    public static void methodStatic(){
        System.out.println("methodStatic in Fu...");
    }
}

// 子类
public class Zi extends Fu {
    int numZi = 100;
    int num = 200;

    public void methodZi() {
        System.out.println("methodZi...");
    }

    @Override 
    public void method() {             // 实例方法重写
        System.out.println("method in Zi...");
    }
    
    public static void methodStatic(){ // 静态方法隐藏
        System.out.println("methodStatic in Zi...");
    }
}

// 测试类
public class Test {
    public static void main(String[] args) {
        Fu fu = new Zi();             // 向上转型
        System.out.println(fu.numFu); // 10 继承的变量
        System.out.println(fu.num);   // 20 隐藏的变量
        fu.methodFu();                // methodFu...     继承的方法
        fu.method();                  // method in Zi... 重写的方法
        fu.methodStatic();            // methodStatic in Fu... 父类的静态方法
    }
}

继承与多态

一个类有很多子类，并且这些子类都重写了父类中的某个方法

子类创建的对象的引用放到一个父类的对象中，得到该对象的一个上转型对象

上转型对象在调用这个方法时可能具有多种形态，不同的子类在重写父类的方法时产生自己的行为

// 动物类
public class Animal {
    void cry() {
    }
}

// 小狗类
public class Dog extends Animal {
    @Override
    void cry() {
        System.out.println("汪汪...");
    }
}

// 小猫类
public class Cat extends Animal {
    @Override
    void cry() {
        System.out.println("喵喵...");
    }
}

// 测试类
public class Test {
    public static void main(String[] args) {
        Animal animal;
        animal = new Dog(); // 向上转型
        animal.cry();       // 汪汪...     
        animal = new Cat(); // 向上转型
        animal.cry();       // 喵喵...
    }
}

接口与多态

电脑通常具备使用USB设备的功能，具备最基本的开启功能和关闭功能

电脑预留可以插入USB设备的USB接口，但具体是什么USB设备，电脑厂商并不关心，只要符合USB规范即可

// USB接口
public interface USB {
    //  打开设备
    public abstract void On();

    // 关闭设备
    public abstract void Off();
}

// 键盘类
public class KeyBoard implements USB {

    @Override
    public void On() {
        System.out.println("打开键盘！");
    }

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

    public void input() {
        System.out.println("键盘输入！");
    }
}

// 鼠标类
public class Mouse implements USB {
    
    @Override
    public void On() {
        System.out.println("打开鼠标！");
    }

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

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

// 电脑类
public class Computer {
    // 电脑开机
    public void powerOn() {
        System.out.println("打开电脑！");
    }
    // 电脑关机
    public void powerOff() {
        System.out.println("关闭电脑！");
    }

    // 使用设备
    // 面向接口编程（关联-接口类型的成员变量，依赖-接口类型的方法参数、返回值）
    public void useDevice(USB usb) {
        usb.On();
        if (usb instanceof Mouse) {
            Mouse mouse = (Mouse) usb;
            mouse.click();
        } 
        if (usb instanceof KeyBoard) {
            KeyBoard keyBoard = (KeyBoard) usb;
            keyBoard.input();
        }
        usb.Off();
    }
}

// 测试类
public class Test {
    public static void main(String[] args) {
        Computer computer = new Computer();
        computer.powerOn();
         /**
         * 接口回调
         * 把实现类创建的对象的引用赋值给接口声明的接口变量，该接口变量就可以调用被类实现的接口方法
         */
        USB usbKeyBoard = new KeyBoard(); // 这里决定使用哪个设备
        computer.useDevice(usbKeyBoard);
        computer.powerOff();
    }
}