多态

多态–01

/*多态*/
public class TestPolymorphism{
    public static void main(String[] args){
        TestPolymorphism p=new TestPolymorphism();
        Animal a=new Dog();//多态的体现：父类的引用或者接口指向了自己的子类
        Animal b=new Cat();//向上转型
        p.method(a);
        p.method(b);
    }
    public static void method(Animal a){
        /*优点：提高了程序的扩展性
            缺点：但是父类引用操作子类对象时，只能引用父类已有的方法，而不能引用子类特有的方法*/
            a.eat(); 
            if(a instanceof  Dog)  {
                Dog x=(Dog)a;//向下转型
                x.lookhome();//调用子类特有的方法
            }   
            else if(a instanceof Cat){
                Cat y=(Cat)a;
                y.catchMouse();
            } 
    }
    /*多态前提：必须具有关系，如继承或实现
                一般有重写操作
    */
}
abstract class Animal{
    public abstract void eat();
}

class Dog extends Animal{
    public void eat(){
        System.out.println("骨头");
    }

    public void lookhome(){
        System.out.println("看家");
    }
}

class Cat extends Animal{
    public void eat(){
        System.out.println("fish");
    }

    public void catchMouse(){
        System.out.println("抓老鼠");
    }
}
/*
使用向上转型：不关系子类型，子类型被隐藏，不需要调用子类的特有方法
              需要使用instanceof判断，避免发生ClassCastException

*/

多态–02

/*练习多态并使用之前学习的内容

需求1：笔记本电脑运行
按照面向对象的方法,用代码体现

需求2：在笔记本电脑上加一个手握式鼠标,鼠标可开启和关闭
*/
public class DemoPolymorphism{
    public static void main(String[] args){
        Notebook n=new Notebook();
        n.run();
        n.useUsb(new Mouse());
        n.useUsb(new Keyboard());
    }
}

interface Usb{//接口的出现，增强了扩展性，定义了规则
    void open();
    void close();
}

class Notebook{
    public void run(){      //运行功能
        System.out.println("notebook run");
    }

    public void useUsb(Usb usb){//使用接口
        if(usb!=null){
            usb.open();
            usb.close();
        }
    }
}

class Mouse implements Usb {
    public void open(){      //鼠标的开启功能
        System.out.println("mouse open");
    }
    public void close(){     //鼠标的关闭功能
        System.out.println("mouse close");
    }
}

class Keyboard implements Usb{
    public void open(){
        System.out.println("keyboard open");
    }
    public void close(){
        System.out.println("keyboard close");
    }
}

多态–03

/*   多态
1.成员变量:当子父类出现同名变量时，多态调用该变量时，编译时期，
参考的是引用型变量所属的类中是否有被调用的成员函数，若没有 编译失败
运行时期也是调用引用型变量所属的类中的成员函数（编译运行都看左边）

2.成员函数:
编译看左边，如果没有编译失败
运行参考右边对象所属的类（编译看左，运行看右）
成员函数动态地绑定到对象

3.静态函数的特点:
编译和运行都看左边
静态函数静态地绑定到类

总结：成员变量和静态函数编译和运行都看左边
      静态函数编译看左边运行看右边
*/
public class FeaturePolymorphism{
    public static void main(String[] args){
        Fu f=new Zi();
        Zi z=new Zi();
        /*测试成员变量的调用
        System.out.println(f.num);//3
        System.out.println(z.num);//5*/
        /*测试成员函数的调用
        f.show();//Zi show run
        z.show();//Zi show run */
        //测试静态函数的调用
        f.run();//Fu static run
        z.run();//Zi static run
    }
}

class Fu{
    int num=3;

    void show(){
        System.out.println("Fu show run");
    }

    static void run(){
        System.out.println("Fu static run");
    }
}

class Zi extends Fu{
    int num=5;

    void show(){
        System.out.println("Zi show run");
    }

    static void run(){
        System.out.println("Zi static run");
    }
}