多态的向上转型，向下转型，及instanceof的用法

定义：同一种行为，具有多种不同的表现形式

格式：父类类型 变量名 = new 子类对象； 
      变量名.方法名();
      Fu f = new Zi(); //父类引用指向子类对象
      f.method();

对象的向上转型

格式：父类类型 变量名 = new 子类对象；(和多态一样)

animal animal = new cat();//创建一只猫当动物看待

从小类型转向大类型

对象的向下转型

格式：子类名称 对象名 = (子类名称) 父类对象；

instanceof的用法

为了避免多态向下转型时出现ClassCastException类型转换异常，所以在向下转型时要进行判断。（对父类是否是子类的实例）
格式：变量名 instanceof 类名称

Cat cat =(Cat) animal;//把被当成动物的猫转成是猫
/*
注意：本来对象创建的时候就是猫，才能向下转型变成猫；
如果本来不是，要强转成是猫，就回报错
*/
//例子
//方法测试
public class Up {
    public static void main(String[] args) {
        animal animal =new cat();//向上转型
        animal.eat();
        cat cat = (cat) animal;//向下转型
        cat.catmouse();
        //dog dog = (dog) animal1；
        //dog.eat(); 这两行代码写在此处，运行时会显示ClassCastException类型转换异常，因为dog 并没有被animal引用过
        System.out.println("=============");
        animal animal1 =new dog();//向上转型
        if (animal1 instanceof dog){//判断animal是不是dog的实例
            dog dog = (dog) animal1;//向下转型
            dog.dogm();
            dog.eat();
        }
    }
}
/*代码运行结果
猫吃鱼
猫抓老鼠
=============
狗看家
狗吃骨头
*/
//子类-dog
public class dog extends animal {
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
    public  void dogm(){
        System.out.println("狗看家");
    }
}
//子类-cat
public class cat extends animal {
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
    public void catmouse(){
        System.out.println("猫抓老鼠");
    }
}
//父类-animal
public abstract class animal {
    public abstract void eat();
}

综合题

本体结合了多态，继承，匿名对象，向上，向下转型，instanceof的用法，如果能理解，对以上概念也会有更深的印象。
题目：
进行描述笔记本类，实现笔记本使用USB鼠标、USB键盘
USB接口，包含开启功能、关闭功能
笔记本类，包含运行功能、关机功能、使用USB设备功能
鼠标类，要实现USB接口，并具备点击的方法
键盘类，要实现USB接口，具备敲击的方法

//主方法
public class demomain {
    public static void main(String[] args) {
        comquter comquter = new comquter();
        comquter.powerOn();
        //创建一个鼠标实现类到usb接口里，向上转型
        Usb usb = new Mouse();//此处已将Mouse的open，close传到接口，也就是Usb接口对Mouse的实例
        comquter.usbDevice(usb);
        //创建一个键盘实现类到usb接口里，左接口，右实现类
        Keybord usb1 =new Keybord();//运用继承的方法，通过调用子类对象也可以向上转型
        comquter.usbDevice(new Keybord());//运用匿名对象也可以调用
        //Usb usb1 =new Keybord(); 正常写法
        // comquter.usbDevice(usb1);正常写法
        comquter.powerOf();
    }
}
/*运行结果
笔记本电脑开机了
打开鼠标
使用鼠标
关闭鼠标
打开键盘
使用键盘
关闭键盘
笔记本电脑关机了

*/
//Usb接口代码
public interface Usb  {
    public void open();
    public void close();
}
//comquter类
public class comquter {//使用接口
     public void powerOn(){
         System.out.println("笔记本电脑开机了");
     }
     public void powerOf(){
         System.out.println("笔记本电脑关机了");
     }
     public void usbDevice(Usb usb){//此处Usb是类 usb是变量名
        usb.open();
        if (usb instanceof Mouse){
            Mouse mouse =(Mouse)usb;//向下转型
            mouse.function();
        }else if (usb instanceof Keybord){
            Keybord keybord =(Keybord)usb;
            keybord.function();
        }
        usb.close();
     }
}
//Mouse类
public class Mouse implements Usb {//实现接口

    @Override
    public void open() {
        System.out.println("打开鼠标");
    }
    @Override
    public void close() {
        System.out.println("关闭鼠标");
    }
    public void function(){
        System.out.println("使用鼠标");
    }
}
//Keybord类
public class Keybord implements Usb {//实现接口
    @Override
    public void open() {
        System.out.println("打开键盘");
    }
    @Override
    public void close() {
        System.out.println("关闭键盘");
    }
    public void function(){
        System.out.println("使用键盘");
    }
}

总结：
1.Mouse的向上转型 Usb usb = new Mouse();一旦发生转型就已将将Usb中的open，close方法重写，把Mouse的open，close方法传入；
2.只有向下转型才需要使用 instanceof 判断 接口是否是对象的实例，向下转型成功的关键就是该对象是不是对应接口的实例。