Java中的多态

多态：同一个对象(事物)，在不同时刻体现不同的状态。

多态的前提：

                1.要有继承关系。

                2.要有方法重写。

                        其实没有也是可以的，但如果没有这个就没有意义。

                              animal d = new cat();

                              d.show();

                              animal d = new dog();         

                              d.show();      

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

                        父 f = new 子();

   多态中的成员访问特点:

                  1.成员变量

                             编译看左边，运行看左边

                  2.构造方法

                            创建子类对象的时候，访问父类构造方法，对父类对象进行初始化。

                  3.成员方法

                             编译看左边，运行看右边。

                  4.静态方法 

                             编译看左边，运行看左边

                                 （静态和类有关，所以算不上重写，所以访问还是左边的）

                 由于成员方法存在重写，所以运行看右边。

   例如：

class Fu{
    public int num=100;
    public void show(){
        System.out.println("show fu");
    }

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

}

class  zi extends  Fu{
    public  int num=200;
    public void show() {
        System.out.println("show zi");
    }
    public void method(){
        System.out.println("method zi");
    }

    public  static void function(){
        System.out.println("function zi");
    }
}

public class duotai {
    public static void main(String[] args) {
            Fu F = new zi();

            F.show();
            //成员变量
            System.out.println(F.num);
            //静态方法
            F.function();
    }
}

运行结果：

 

多态的好处：

             1.提高了代码的维护性

             2.提高了代码的扩展性

猫狗案例的实现：

第一版：

class Animal{
    public void eat(){
        System.out.println("eat");
    }
    public void sleep(){
        System.out.println("sleep");
    }
}

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

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

public class duotai {
    public static void main(String[] args) {
        Animal a = new Animal();
        cat c = new cat();
        dog d = new dog();
        System.out.println("调用猫的方法----------");
        c.eat();
        c.sleep();
        System.out.println("调用狗的方法-----------");
        d.eat();
        d.sleep();
    }
}

运行结果：

当对象创建太多时，而除了对象不同，调用方法都一样，所以这种方法就产生了不便。

第二版：

class Animal{
    public void eat(){
        System.out.println("eat");
    }
    public void sleep(){
        System.out.println("sleep");
    }
}

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

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

class  AnimalTool{
    private AnimalTool(){}
    public static void userCat(cat c){
        c.sleep();
        c.eat();
    }

    public static void userDog(dog d){
        d.sleep();
        d.eat();
    }
}

public class duotai {
    public static void main(String[] args) {
        Animal a = new Animal();
        cat c = new cat();
        dog d = new dog();
        AnimalTool.userCat(c);
        System.out.println("--------------");
        AnimalTool.userDog(d);
//        System.out.println("调用猫的方法----------");
//        c.eat();
//        c.sleep();
//        System.out.println("调用狗的方法-----------");
//        d.eat();
//        d.sleep();
    }
}

运行结果：

 优点：此方法比第一种方法简单许多，把调用方法封装在AnimalTool方法中，只需在声明对象之后调用AnimalTool方法中的方法，无需每创建一个对象都调用方法。

缺点：每次调用对象方法都会调用对象的全部属性。

第三版(多态版)：

class Animal{
    public void eat(){
        System.out.println("eat");
    }
    public void sleep(){
        System.out.println("sleep");
    }
}

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

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

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

class  AnimalTool{
    private AnimalTool(){}
//    public static void userCat(cat c){
//        c.sleep();
//        c.eat();
//    }
//
//    public static void userDog(dog d){
//        d.sleep();
//        d.eat();
//    }
//
//    public static void userPig(pig p){
//        p.sleep();
//        p.eat();
//    }
    public static void userAnimal(Animal a){
        a.eat();
        a.sleep();
    }

}

public class duotai {
    public static void main(String[] args) {
        Animal a = new dog();
       // cat c = new cat();
        //dog d = new dog();
       // pig p=new pig();
        Animal a2=new pig();
        Animal a1=new cat();//多态
        AnimalTool.userAnimal(a1);
        System.out.println("--------------");
       // AnimalTool.userCat(c);
        AnimalTool.userAnimal(a);
        //System.out.println("--------------");
       //AnimalTool.userDog(d);
        //AnimalTool.userAnimal(a1);
        System.out.println("--------------");
        AnimalTool.userAnimal(a2);//
        //AnimalTool.userPig(p);
//        System.out.println("调用猫的方法----------");
//        c.eat();
//        c.sleep();
//        System.out.println("调用狗的方法-----------");
//        d.eat();
//        d.sleep();
    }
}

运行结果：

多态的弊端：

            1.不能直接使用子类特有功能。

  调用子类特有方法的方法：

           向下转型：把父类的引用强制转换为子类的引用。

例如：

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

    public void  method(){
        System.out.println("method Zi");
    }
}

public class duotai_biduan {
    public static void main(String[] args) {
        Fu f = new Zi();
       //f.method();
        f.show();
        ((Zi) f).method();//向下转型
        System.out.println("------------------------");
        Zi z=(Zi) f;
        z.method();
        z.show();


    }
}

运行结果：