[16]多态

java面向对象的三大特性：继承，封装，多态

继承和封装也为多态做了铺垫。

多态的概念，这里我说的我的理解。概念我理解，但我自问自己能不能时刻记住多态的概念。我投降

多态其实就是一个引用指向多个对象。

打个比方：

班主任找班里的重要人员去101开个会，如果说学习委员，卫生委员，班长，副班长，体育委员，文艺委员，宣传委员等等。

你感觉老师会这么蠢吗？一般来说，班主任会直接说：班级干部来101开一下会。

所以虽说只引用班级干部，但是却指向了很多对象。

代码体现：

父类 引用变量=new 子类对象();//是两个类型

例子：

class Animal{
    String name;
}

class Cat extends Animal{
}

class Dog extends Animal{
    
}

class Demo{
    public static void main(String[] args){
        Animal a=new Dog();
        Animal a2=new Cat();
    }
}

【多态的优点（以例子说话）】

1.扩展性：

就算派生了其他的子类，也不会影响已存在的子类。

2.灵活性，复用性：

你敢信可以用父类引用调用子类的属性和行为？

class Person{
    public void drinkWater(Cup c){
        System.out.println("use "+Cup.getName()+" drink water")
    }
}

class Cup{
    private String name;

    public void setName(String name){
        this.name=name;
    }

    public String getName(){
        return this.name;
    }
    public Cup(String name){
        this.name=name;
    }
}
@override
class Mug extends Cup{
    public Cup(String name){
        super(name);
    }
}

class Demo{
    public static void main(String[] args){
        Cup c=new Mug("马克杯");
        Person p=new Person();
        p.drinkWater(c);
    }
}

 【多态的弊端】

通过父类引用操控子类对象，只能操作父类和子类共有的方法，而子类自己衍生的方法或是属性是无法操控的。

换句话来说，爸爸教了儿子打篮球之后。爸爸和儿子都可以调用打篮球。儿子自己学会踢足球。爸爸会吗？爸爸不会怎么调用踢足球这个方法。

class Fu{
    String name;
    public void show(){
        System.out.println("Fu");
    }
}

class Zi extends Fu{
    public void show(){
        super.show();
    }
    
    public void show2(){
        System.out.println("Zi");
    }
}

class Demo{
    public static void main(String[] args){
        Fu f=new Zi();
        f.show();//编译通过
        f.show2();//报错
    }
}

【多态的前提】

1.必须由关系：继承或者接口都行。

2.通常子类继承父类后通常要重写父类的方法。 

3.父类的引用指向子类对象。

那如果子类的对象，父类该如何调用呢？

通过instance关键字向下转型

class Fu{
    public void work(){
        System.out.println("工作");
    }
}

class Zi extends Fu{
    public void work(){
        super.work();
    }

    public void practice(){
        System.out.prinln("引体向上50个，再加200个俯卧撑，300个仰卧起坐，加5*500米快速跑");
    }
}

class Nv extends Fu{
}

class Demo{
    public static void main(String[] args){
        Fu f=new Zi();
        Fu f2=new Nv():
        f.work();
        if(f instanceof Zi){
            Zi zf=(Zi)f;
            zf.practice();
        }else{
            new ClassCastExcetion("快停下朋友，你是疯了吗？我以后只能托梦见你了？")
        }
    }
}

向上转型：就是我们所说的多态。

向下转型：可以理解为基本数据类型中的强制类型转换。

那么为什么要用instanceof呢？

因为如果女儿也继承父类，然后也向下转型了。然后如果成功了，调用了儿子的锻炼。

结果只有2个：1.恭喜你，第二天就可以全家烧香了。2.恭喜你，你女儿这么身材那么的彪悍都能结婚。

【实例】：实例其实很多，网上可以找到很多，本人就举一个例子了

【笔记本和USB的故事】

interface USB{ 
    public void setName(String name);
    public String setName();
}

class Mouse implements USB{
    public Mouse(String name){
        this.name=name;
}
    public void setName(String name){
        this.name=name;
    }
    public String getName(){
        return name;
    }
}

class KeyBoard implements USB{
    public KeyBoard(String name){
        this.name=name;
    }    
    public void setName(String name){
        this.name=name;
    }
    public String getName(){
        return name;
    }
}

class abstract Computer{
    private String name;
    public void setName(String name){
        this.name=name;
    }
    public String getName(){
        return name;
}
    public void open(){
        System.out.println("打开电脑");
    }
    public void close(){
        System.out.println("关闭电脑");
    }
    publc void useUSB(Computer c,USB u);
}

class NoteBook extends Computer{
    public void open(){
        super.open();
    }
    public void close(){
        super.close();
    }
    public void useUSB(Computer c,USB u){
        super.useUSB(c,u);
    }
    publc void useUSB(Computer c,USB u){
        System.out.println(c.getName()+" use "+u.getName());
    }
}

class Demo{
    public static void main(String[] args){
        Computer c=new NookBook("笔记本");
        c.open();
        c.close();
        c.useUSB(c,new Mouse("鼠标"));
    }
}