java语言进阶篇7——多态

1、多态的概念

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

2、多态的格式与使用

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

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

3、多态中成员变量和成员方法的使用特点

• 在多态的代码中，成员方法的访问规则是：看new的是谁，就优先用谁，没有则向上找。
• 口诀：
  成员变量：编译看左边，运行还看左边。
  成员方法：编译看左边，运行看右边。

 // 定义父类
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();              
    } 
}

4、使用多态的好处

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

5、对象的向上转型和向下转型

• 向上转型 ：多态本身是子类类型向父类类型向上转换的过程，这个过程是默认的。当父类引用指向一个子类对象时，便是向上转型。
• 使用格式：
  父类类型 变量名 = 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        
    } 
}

6、instanceof关键字

• 为了避免转型的过程中ClassCastException的发生，Java提供了 instanceof 关键字，给引用变量做类型的校验。
• 格式：
  变量名 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;      
            d.watchHouse();       // 调用的是 Dog 的 watchHouse
        }
    } 
}

7、接口多态的综合案例——笔记本电脑

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

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

// 定义USB接口
public interface USB{
	public abstract void open(); //打开设备
	public abstract void close();  //关闭设备
}
// 定义鼠标类
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("使用鼠标");
    }
}
//定义键盘类
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("键盘输入");
    }
}
// 定义笔记本类
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(); //关闭设备
    }
}
}
//定义测试类
public class DemoComputer {
    public static void main(String[] args) {
        Computer computer = new Computer();  //创建一个电脑对象
        computer.powerOn(); //打开电脑
        //多态写法，创建一个鼠标
        USB useMouse = new Mouse();  //向上转型
        computer.useDevice(useMouse);  //将USB类型作为参数传入电脑的成员方法
        //创建一个键盘
        USB useKeyboard = new Keyboard();
        computer.useDevice(useKeyboard);
        //匿名对象写法
        computer.useDevice(new Keyboard());
        computer.powerOff();
    }

输出结果：
电脑开机
打开鼠标
使用鼠标
关闭鼠标
打开键盘
键盘输入
关闭键盘
打开键盘
键盘输入
关闭键盘
电脑关机