面向对象多态以及转型

多态：

定义：某一事物的多种存在的形态

例如：动物中的猫狗

猫这个对象对应的类型是猫类型

猫 x = new 猫（）；

同时猫也是动物的一种，也可以把猫称为动物

动物 y = new 猫（）；

动物是猫和狗具体事务中抽取出来的父类型

父类型引用指向子类对象

多态性：在程序中体现，就是：父类或者接口的引用指向自己的子类对象

好处：提高了代码的扩展性

弊端：前期建立父类引用虽然可以接收后期所有该类的子类对象，但是只能使用父类中的功能，不能使用子类中的特有功能，因为前期的程序无法知道后期的子类特有的内容

前提：必须存在继承关系，通常要有覆盖操作

package com_package1;

public class Bibi {
    public void function()
    {
        
        System.out.println("zhuchi");
    }
    public void fishing()
    {
        System.out.println("fishing");
    }

}

package com_package1;

public class Bibi {
    public void function()
    {
        
        System.out.println("zhuchi");
    }
    public void fishing()
    {
        System.out.println("fishing");
    }

}

package com_package1;

public class DuotaiDemo1 {
   
    public static void main(String[]args)
    {
        Bibi b = new Bibier();
        b.fishing();
        b.function();
        //b.movie();
        
    }
}
//b这种对象只可以调用他们之间共有的方法和父类中特有的方法，在显示的时候，共有的方法会显示子类中的方法

关于instanceof

package com_package1;

public class Dog extends Animal{
    
    public void eat()
    {
        
        System.out.println("啃骨头");
    }//将父类中的抽象方法实例化
    public void lookHome()
    {
        System.out.println("看家");
    }//够的特有属性

}

package com_package1;

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

package com_package1;

public class Pig extends Animal{
   public void eat()
   {
       
       System.out.println("siliao");
   }
   public void gongDi() {
       System.out.println("gongdi");
    
}
}

package com_package1;

public class DuotaiDemo {
       public static void main(String[]args)
       {
           Pig p  = new Pig();
           Dog d = new Dog();
           Cat c = new Cat();
           method(p);
           method(d);
           method(c);
           
       }
      //在进行子类特有方法使用时，要进行向下转型，转型前一定要做判断，否则容易发生ClassCastException

判断引用类型，要使用一个关键字完成：关键字 instanceof

       public static void method(Animal a)
       {    a.eat();
           if(a instanceof Cat)
          
           {Cat c =  (Cat)a;
           c.catchMouse();}
           else if(a instanceof Dog)
           {  Dog d = (Dog)a;
              d.lookHome();
              }
           else
           {Pig p = (Pig)a;
           p.gongDi();}
       }

}

多态，成员变量和成员函数以及静态函数的特点

成员变量示例：编译时期：参考的是引用型变量所属的类Fu5中是否有调用的成员变量，如果有，那么编译通过。运行时期：调用的也是引用型变量所属的类中的成员，简单的说：编译和运行都看等号的左边，其实这种情况并不多见。

package com_package1;

public class Fu5 {
    int num = 4;

}

package com_package1;

public class Fu5 {
    int num = 4;

}

package com_package1;

public class DuotaiDemo5 {
    public static void main(String[]args)
    {
        Fu5 z = new Zi5();
        System.out.println(z.num);
        
        
    }

}

//成员变量会显示父类的成员变量

成员函数示例：编译时期：参考的是引用型所属的类Fu6中是否有调用的方法，如果有，则编译通过，没有则编译失败。运行时期：参考的是对象所属的类中是否有调用方法，如果有，就运行子类自己的方法，如果没有的话就调用父类中的方法。

package com_package1;

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

}

package com_package1;

public class Zi6 extends Fu6 {
    
    public void show()
    {
        
        System.out.println("zi show run");
    }

}

package com_package1;

public class DuotaiDemo6 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        
        Fu6 z =  new Zi6();
        z.show();
        
        
        // TODO Auto-generated method stub

    }

}

zi show run

静态成员函数：注意静态成员函数是随类的产生而产生。编译时期：参考的而是引用类型变量所属的类Fu6中是否有该方法。运行时期：参考的也是引用型变量所属的类Fu6中的方法

简单的说：编译和运行都看左边。因为静态方法是不属于对象的，是属于类的，他会在类加载的时候，静态的绑定到所属的类上。

package com_package1;

public class Fu6 {
    public static void show()
    {
        System.out.println("Fu show run");
        
    }

}

package com_package1;

public class Zi6 extends Fu6 {
    
    public static void show()
{
        
        System.out.println("zi show run");
    }

}

package com_package1;

public class DuotaiDemo6 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        
        Fu6 z =  new Zi6();
        z.show();
        
        
        // TODO Auto-generated method stub

    }

}

Fu show run

接口和多态练习

package com_package1;

public class NoteBook {
    public void run()
    {
        
        System.out.println("enable");
        System.out.println("disabble");
    }
    public void useUSB(USB u)
    {
        if(u!=null)
        {
            u.able();
            u.enable();
            
        }
        
    }
}

package com_package1;

public interface USB {
    public void able();
    public void enable();

}

package com_package1;

public class UDisk implements USB {

    @Override
    public void able() {
        // TODO Auto-generated method stub
        System.out.println("disk able");
    }

    @Override
    public void enable() {
        // TODO Auto-generated method stub
     System.out.println("disk enable");        
    }
    


}

package com_package1;

public class Umouse implements USB{

    @Override
    public void able() {
        // TODO Auto-generated method stub
        System.out.println("mouse able");
    }

    @Override
    public void enable() {
        // TODO Auto-generated method stub
        System.out.println("mouse enable");
        
    }
    

}

package com_package1;

public class NoteBookDemo {
    public static void main(String[]args)
    {
        NoteBook nt = new NoteBook();
        nt.run();
    //    nt.useUSB(u);
        nt.useUSB(null);
        nt.useUSB( new UDisk());
        nt.useUSB(new Umouse());
        
    }

}