多态

extends继承或者implemerts实现，是多态的前提（多态指的是对象）

多态运行的特点：

成员方法：编译看左，运行看右

成员变量：编译看左，运行也看左

• 子类重写运行子类（成员方法调用的是子类的成员变量），没有重写运行父类（成员方法调用的是父类的成员变量）
• 等号右边是谁调用的就是谁（成员变量）

 

多态使用的格式

• 父类名称 对象名 = new 子类名称();
• 接口名称 对象名 = new 实现类名称();

public class Demo01Multi {
    public static void main(String[] args) {
        Fu fu = new Zi();    
        fu.method();             //运行子类成员方法 
        fu.method1();            //运行父类成员方法
        System.out.println(fu.num);    //调用父类成员变量，成员变量编译和运行都是看左边
        fu.method2();            //运行父类成员方法，调用父类成员变量（子类没有重写该方法）
        fu.method3();           //运行子类成员方法，调用子类成员变量（子类重写该方法）
    }
}
public class Fu {
    int num = 10;
    public void method(){
        System.out.println("父类方法");
    }
    public void method1(){
        System.out.println("父类特有方法");
    }
    public void method2(){
        System.out.println(num);
    }
    pubic void method3(){
        System.out.println(num);
    }
}
public class Zi extends Fu {
    int num = 20;
    @Override
    public void method(){
        System.out.println("子类方法！！");
    }
    @Override
    pubic void method3(){
        System.out.println(num);
    }
}

多态的好处：

public class Demo02Multi {
    public static void main(String[] args) {
        Employee employee1 = new Teacher();
        employee1.work();        //teacher 讲课
        employee1 = new Assistant();
        employee1.work();        //Assistant 辅导
    }
}
public abstract class  Employee {
    public abstract void work();
}
public class Teacher extends Employee {
    @Override
    public void work() {
        System.out.println("teacher 讲课");
    }
}
public class Assistant extends Employee {
    @Override
    public void work() {
        System.out.println("Assistant 辅导");
    }
}

对象的向上转型

格式：父类名称 对象名 = new 子类名称();         父类引用指向子类对象

含义：创建一个子类对象把它当做父类来看待使用

注意事项：向上转型一定是安全的，从小范围转向了大范围

弊端：不能使用子类特有的方法

对象的向下转型

其实是一个还原过程

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

含义：将父类对象还原成本来的子类对象 

注意事项：向下转型不是安全的，从大范围转向了小范围

弊端：必须保证向下转型的类型和本来就属于的类型（大范围转向了小范围），否则会出现类转换异常（ClassCastException）

可以通过 instanceof 关键字来判断原始类型

if(要转换的对象 instanceof 判断是否属于该引用类型){
}

多态的应用

public class Demo04Multi {
    public static void main(String[] args) {
        LapTop lapTop = new LapTop();
        Keyboard keyboard = new Keyboard();
        Mouse mouse = new Mouse();
        lapTop.usbjk(keyboard);
        lapTop.usbjk(mouse);
    }
}
public interface USB {
    public abstract void open();
    public abstract void close();
}
public class Keyboard implements USB {
    public void qj() {
        System.out.println("我能敲击！！");
    }

    @Override
    public void open() {
        System.out.println("打开鼠标设备");
    }

    @Override
    public void close() {
        System.out.println("关闭鼠标设备");
    }
}
public class Mouse implements USB {

    public void dj() {
        System.out.println("我能点击！！");
    }

    @Override
    public void open() {
        System.out.println("打开键盘设备");
    }

    @Override
    public void close() {
        System.out.println("关闭键盘设备");
    }
}
public class LapTop {
    public void usbjk(USB usb){
        usb.open();
        if (usb instanceof Keyboard){
            Keyboard keyboard = (Keyboard)usb;
            keyboard.qj();
        }else if (usb instanceof Mouse){
            Mouse mouse = (Mouse)usb;
            mouse.dj();
        }
        usb.close();
    }
}