java-多态

多态：同一个对象拥有多种形态
举个例子，首先创建两个类：猫和狗，猫具有的动作：猫吃鱼，狗具有的动作：狗吃骨头。
代码如下：

public class cat {
    public void eat(){
        System.out.println("猫吃鱼");
    }
}

public class dog {
    public void eat(){
        System.out.println("狗吃骨头");
    }
}

然后，铲屎官来啦，创建一个类：人，动作是：喂猫和喂狗。

public class person {
    public void feedcat(cat c){//喂猫
        c.eat();//猫可以吃
    }
    public void feeddog(dog d){//喂狗
        d.eat();//狗也有吃的动作
    }
}

创建一个程序入口：client:

public class client {
    public static void main(String[] args){
        person p =new person();
        cat c= new cat();
        dog d = new dog();
        p.feedcat(c);
        p.feeddog(d);
    }
}

然后，现在想再加一个类，大象 动作是：大象吃香蕉
public class daxiang {
public void eat(){
System.out.println(“大象吃香蕉”);
}
}
然后人，需要再加一个动作就是，喂大象：

public class person {
    public void feedcat(cat c){
        c.eat();
    }
    public void feeddog(dog d){
        d.eat();
    }
    public void feeddaxiang(daxiang dx){
        dx.eat();
        
    }
}

person类中需要再加一个动作就是喂大象：

public class person {
    public void feedcat(cat c){
        c.eat();
    }
    public void feeddog(dog d){
        d.eat();
    }
    public void feeddaxiang(daxiang dx){
        dx.eat();

    }
}

client也需要加入：

public class client {
    public static void main(String[] args){
        person p =new person();
        cat c= new cat();
        dog d = new dog();
        daxiang dx=new daxiang();
        p.feedcat(c);
        p.feeddog(d);
        p.feeddaxiang(dx);
    }
}

但是可以看到，其实person代码中是有很多重复的，怎么可以简写呢？
可以想到，猫是一种动物，狗也是一种动物，大象也是一种动物。（）什么是一种什么，也就想到了Java中的继承。
创建一个动物的类：

public class animal {
    public void eat(){
        System.out.println("动物在吃");
    }
}

输出：

然后那些猫、狗、大象就都可以继承动物的属性，吃
我们知道 cat c = new cat();就是创建一只猫，也就是创建了猫类型的猫，那么可以把猫当成动物来看，也就是：animal ani = new cat();
然后所有的类都可以继承动物的属性了，因此：

public class daxiang extends animal
public class dog extends animal
public class cat extends animal

然后程序入口即：

public class client {
    public static void main(String[] args){
//        person p =new person();
//        cat c= new cat();
//        dog d = new dog();
//        daxiang dx=new daxiang();
//        p.feedcat(c);
//        p.feeddog(d);
//        p.feeddaxiang(dx);
        animal ani1 = new cat();//可以把猫当成动物来看，把子类的对象赋值给父类的引用(变量)，向上转型
        animal ani2=new dog();
        animal ani3=new daxiang();
        person p = new person();
        p.feedanimal(ani1);
        p.feedanimal(ani2);
        p.feedanimal(ani3);


    }
}

类：人就可以改了：

public class person {
    public void feedanimal(animal ani){//接收到的所有的动物都是animal
        ani.eat();//这里就有多态性的体现啦
    }

//    public void feedcat(cat c){
//        c.eat();
//    }
//    public void feeddog(dog d){
//        d.eat();
//    }
//    public void feeddaxiang(daxiang dx){
//        dx.eat();
//
//    }
}

输出：


那么，有向上转型，就有向下转型
比如，猫还有抓老鼠的本领，但是动物并没有。因此向上转型的缺点就出来了，它会屏蔽子类中特有的属性。因此，使用向下转型转回来：
cat新加一个方法，抓老鼠

public class cat extends animal {
    public void eat(){
        System.out.println("猫吃鱼");
    }
    public void catchmouse(){
        System.out.println("猫抓老鼠");
    }
}

修改程序入口：

public class client {
    public static void main(String[] args){
//        person p =new person();
//        cat c= new cat();
//        dog d = new dog();
//        daxiang dx=new daxiang();
//        p.feedcat(c);
//        p.feeddog(d);
//        p.feeddaxiang(dx);
        animal ani1 = new cat();//可以把猫当成动物来看，把子类的对象赋值给父类的引用(变量)，向上转型
        animal ani2=new dog();
        animal ani3=new daxiang();
        person p = new person();
        p.feedanimal(ani1);
        p.feedanimal(ani2);
        p.feedanimal(ani3);
        cat cc = (cat)ani1;//向下转型，
        cc.catchmouse();


    }
}

输出:

举例一个习题，一个三个玩家打三个游戏：

首先创建一个Game 类：

public class Game {
    public void start(){
        System.out.println("开机啦");
    }
    public void play(){
        System.out.println("玩游戏");
    }
    public void end(){
        System.out.println("关机啦");
    }
}

然后三个游戏的类，图中可知，和Game 是继承关系：
贪吃蛇

public class tanchishe extends Game{
    public void play(){
        System.out.println("喜欢玩贪吃蛇");
    }
}

消消乐：

public class xiaoxiaole extends Game{
    public void play(){
            System.out.println("消消乐太好玩了");
    }
}

原神：

public class yuanshen extends Game{
    public void play(){
        System.out.println("玩原神的都聪明");
    }
}

然后创建玩家player类：

public class player {
    public void happy(Game game){
        game.start();
        game.play();
        game.end();

        System.out.println("开心的很呢！");
    }
}

然后创建程序入口：
要求是创建三个游戏对象，然后新建一个玩家对象，然后这个玩家去玩这三个游戏。

public class client {
    public static  void main(String[] args){
        Game game1= new tanchishe();
        Game game2= new xiaoxiaole();
        Game game3= new yuanshen();
        player play = new player();

        play.happy(game1);
        play.happy(game2);
        play.happy(game3);


    }
}