java的多态

对象的多态性：父类的引用指向子类的对象

父类类型 变量名 = 子类对象；

Person p = new Student();

对象的多态：在Java中，子类的对象可以替代父类的对象使用。所以，一个引用类型变量可能指向(引用)多种不同类型的对象

Java引用变量有两个类型：编译时类型和运行时类型。编译时类型由声明该变量时使用的类型决定，运行时类型由实际赋给该变量的对象决定。简称：编译时，看左边；运行时，看右边。

• 若编译时类型和运行时类型不一致，就出现了对象的多态性(Polymorphism)
• 多态情况下，“看左边”：看的是父类的引用（父类中不具备子类特有的方法） “看右边”：看的是子类的对象（实际运行的是子类重写父类的方法）

多态的使用前提：① 类的继承关系 ② 方法的重写

public class Pet { 
    private String nickname; //昵称
    public String getNickname() {
        return nickname;
    }

    public void setNickname(String nickname) {
        this.nickname = nickname;
    }

    public void eat(){
        System.out.println(nickname + "吃东西");
    }
}

public class Cat extends Pet { 
//子类重写父类的方法 
    @Override public void eat() { 
        System.out.println("猫咪" + getNickname() + "吃鱼仔"); 
    }

//子类扩展的方法
    public void catchMouse() {
        System.out.println("抓老鼠");
    }
} 

public class Dog extends Pet { 
//子类重写父类的方法 
    @Override public void eat() { 
        System.out.println("狗子" + getNickname() + "啃骨头"); 
    }

//子类扩展的方法
    public void watchHouse() {
        System.out.println("看家");
    }    
}

public class TestPet { 
    public static void main(String[] args) { 
//多态引用 
        Pet pet = new Dog(); 
        pet.setNickname("小白");

    //多态的表现形式
    /*
    编译时看父类：只能调用父类声明的方法，不能调用子类扩展的方法；
    运行时，看“子类”，如果子类重写了方法，一定是执行子类重写的方法体；
     */
        pet.eat();//运行时执行子类Dog重写的方法
      //  pet.watchHouse();//不能调用Dog子类扩展的方法

        pet = new Cat();
        pet.setNickname("雪球");
        pet.eat();//运行时执行子类Cat重写的方法
    }
}

形参多态

public class Person{ 
    private Pet pet; 
    public void adopt(Pet pet) {
//形参是父类类型，实参是子类对象 
        this.pet = pet; } 
    public void feed(){ 
        pet.eat();
//pet实际引用的对象类型不同，执行的eat方法也不同 
    } 
}

public class TestPerson { 
    public static void main(String[] args) { 
        Person person = new Person();

        Dog dog = new Dog();
        dog.setNickname("小白");
        person.adopt(dog);//实参是dog子类对象，形参是父类Pet类型
        person.feed();

        Cat cat = new Cat();
        cat.setNickname("雪球");
        person.adopt(cat);//实参是cat子类对象，形参是父类Pet类型
        person.feed();
}
} 

返回值多态

public class PetShop { 
//返回值类型是父类类型，实际返回的是子类对象 
    public Pet sale(String type){ 
        switch (type){ 
            case "Dog": return new Dog(); 
            case "Cat": return new Cat(); 
        } 
        return null; 
    } 
} 

public class TestPetShop { 
    public static void main(String[] args) { 
        PetShop shop = new PetShop();

        Pet dog = shop.sale("Dog");
        dog.setNickname("小白");
        dog.eat();

        Pet cat = shop.sale("Cat");
        cat.setNickname("雪球");
        cat.eat();
}
}