Java实现多态

要求

（1）定义一个宠物类(Pet),它有两个方法：叫cry(),吃东西eat(),定义宠物的子类狗(Dog),猫(Cat),覆盖父类的cry(),eat()方法，另外狗有自己的方法看门guardEntrance()，猫自己独有的方法捉老鼠huntMice()定义一个Test类,在main中定义两个Pet变量,pet1,pet2，采用引用转型实例化Dog,Cat,分别调用Pet的cry(),eat();

(2)将Pet引用强制转换为具体的Dog，Cat，在调Dog的guardEntrance（），Cat的huntMice()（提示：先用instanceof进行类型判断）

 (3)编写PetPark类，添加喂养宠物feedPet(Pet pet)的方法,在feedPet中调cry(),eat()方法,实例化PetPark类，再测试类中实例化狗 Dog dog = new Dog(), 猫 Pet cat = new Cat(),PetPark分别调feedPet()方法分别传参数cat,dog。

1.编写PetPark类，添加喂养宠物feedPet(Pet pet)的方法,在feedPet中调cry(),eat()方法,实例化PetPark类；

package Work;
public class PetPark {
    // 编写PetPark类，添加喂养宠物feedPet(Pet pet)的方法,在feedPet中调cry(),eat()方法,实例化PetPark类，
    // 再测试类中实例化狗 Dog dog = new Dog(), 猫 Pet cat = new Cat(),PetPark分别调feedPet()方法分别传参数cat,dog。
    public static void feedPet(Pet pet){
     //类是创建对象的模板,创建对象也叫类的实例化
        pet.cry("+");
        pet.eat("+");
    }
}

2.编写Pet类，编写cry（）和eat（）方法；

package Work;

public class Pet{

   public String cry(String name){
       System.out.println("哭泣");
       return name;
   }
    public String eat(String name){
        System.out.println("吃饭");
        return name;
    }
}

3.编写dog类，使之继承pet类，调用其cry（）和eat（）方法，并编写dog子类的方法guardEntrance（）；

package Work;

public class Dog extends Pet{

        public String cry(String name){
            System.out.println(name+"狗叫");
            return name;
        }

        public String eat(String name) {
            System.out.print(name+"狗吃了肉"+"\n");
            return name;
        }

        public void guardEntrance() {

            System.out.print("狗看门"+"\n");
        }
    }

4..编写cat类，使之继承pet类，调用其cry（）和eat（）方法，并编写dog子类的方法huntMice（）；

package Work;

public class Cat extends Pet{


        public String cry(String name) {
            System.out.print(name+"猫叫"+"\n");
            return name;
        }

        public String eat(String name) {
            System.out.print(name+"猫吃了鱼"+"\n");
            return name;
        }
        public void huntMice(){
            System.out.print("猫捉老鼠"+"\n");
        }
    }

5.编写测试类，实例化dog，cat对象，实现其方法，此时需要关键字instanceof关键字实现向下转型；

instanceof关键字：

1. 在多态中用于向下转型，因为子啊多态发生时，子类只能调用父类中的方法，而子类自己独有的方法无法调用，如果强制调用的话就需要向下转型，语法和基本类型的强制类型转换是一样的，但是向下转型具有一定风险，这时候需要instanceof关键字进行一个判断，然后进行转换操作；
2. 语法为：引用类型变量（object）instanceof 类（class）；
3. instanceof前面的引用变量编译时类型要么与后面的类型相同，要么与后面的类型具有父子继承关系；
4. 判断前面的对象是否属于后面的类，或者属于其子类；
5. 判断结果是，返回true，否则返回false；

package Demo;

import Work.Cat;
import Work.Dog;
import Work.Pet;
import Work.PetPark;

public class Test {
        public static void main(String[] args) {
            Pet pet1=new Dog();
            Pet pet2=new Cat();
            pet1.cry("*");
            pet1.eat("*");
            pet2.eat("*");
            pet2.cry("*");

            Pet dog=new Dog();
            Dog dog1=(Dog) dog;

            Pet cat=new Cat();
            Cat cat1=(Cat) cat;

            new Pet().eat("&");
            new Pet().cry("&");

            Pet i = new Cat();
            i.eat("$");
            i.cry("$");


            if(i instanceof Pet) {
                //判断i指向的对象是不是Cat()指向的对象
                Cat r = (Cat)i;
                //通过将父类强制转换为子类调用其方法
                r.eat("-");
            }
            if(dog1 instanceof Dog) {
                //判断i指向的对象是不是Cat()指向的对象
                Dog r = (Dog)dog1;
                //通过将父类强制转换为子类调用其方法
                r.guardEntrance();
            }

            if(cat1 instanceof Cat) {
                //判断i指向的对象是不是Cat()指向的对象
                Cat r = (Cat)cat1;
                //通过将父类强制转换为子类调用其方法
                r.huntMice();
            }

            //判断guardEntrance
            System.out.println(dog1 instanceof Dog);
            dog1.guardEntrance();
           //判断huntMice
            System.out.println(cat1 instanceof Cat);
            cat1.huntMice();


            PetPark.feedPet(cat);
            PetPark.feedPet(dog);
        }
}