当前位置：首页 > news >正文

2019-1-21作业

news 来源：原创 2024/5/2 11:40:07

作业一：使用多态实现主人领养宠物，和宠物玩的功能，

父类，宠物类：

package com.polym02;

/**
 * 父类 ，宠物类
 */
public abstract class Pet {
   //宠物被领养的方法
    public  Pet yang(Pet pet){
        return pet;
    }
}

子类狗：

package com.polym02;

/**
 * 狗狗类
 */
public class Dog extends Pet {
    //玩的方法
    public void wang() {
        System.out.println("陪狗狗去接飞盘");
    }
   //重写父类被领养的方法
    public  Pet yang(Pet pet){
        System.out.println("给你一只狗狗");
        return pet;
    }
}

子类企鹅：

package com.polym02;

/**
 * 企鹅类
 */
public class Penguin extends Pet {
    //玩的方法
    public  void  wang(){
        System.out.println("带企鹅去游泳。。。。。。");
    }
    //重写父类被领养的方法
    public  Pet yang(Pet pet){
        System.out.println("给你一只企鹅。。。。。");
        return pet;
    }
}

主人类：

package com.polym02;

/**
 * 主人类
 */
public class Master {//带宠物出去玩的方法
    public  void  quWang(Pet pet){
       if(pet instanceof Dog){
           Dog dog = (Dog)pet
           dog.wang();
       }else if (pet instanceof Penguin){
         Penguin pen =(Penguin)pet
           pen.wang();
       }
    }
    //领养宠物的方法
    public Pet lingYang(Pet pet) {
        Pet p = null;
        if (pet instanceof Dog) {
          
            pet.yang(p1);
            p = pet;
        }else if(pet instanceof  Penguin){
           pet.yang(p2);
            p =pet;
        }
        return p;
    }
}

测试类：

package com.polym02;

import java.util.Scanner;

public class Test {
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        Master m = new Master();
        Pet P1 = new Dog();
        Pet P2 = new Penguin();
        System.out.println("请输入要陪玩的宠物：1，狗狗   2，企鹅");
        int choose = sc.nextInt();
        if (choose==1){
            m.quWang(P1);
        }else{
            m.quWang(P2);
        }
        System.out.println("请输入你需要的宠物：1，狗狗    2，企鹅");
        int choose02 = sc.nextInt();
        if (choose02==1){
            m.lingYang(P1);
        }else{
            m.lingYang(P2);
        }
    }
}

输出结果图：

作业二2：

使用多态实现为宠物喂食：

父类宠物类：

/**
     * 宠物健康值
     */
    private int intimacy=46;
    /**
     * 宠物亲密度
     */
    private int health=0;

    public int getHealth() {
        return health;
    }

    public void setHealth(int health) {
        this.health = health;
    }

    public int getIntimacy() {
        return intimacy;
    }

    public void setIntimacy(int intimacy) {
        this.intimacy = intimacy;
    }

    /**
     * 宠物吃食的方法
     */
    public abstract void eat();
}

子类狗：

package com.Polym;

public class Dog extends Pet {
    public  void eat(){
        if(getIntimacy()<50){
            System.out.println("给狗狗吃狗粮和肉骨头");
            setIntimacy(getIntimacy()+20);
            System.out.println("狗狗现在的健康值是："+getIntimacy());
            setHealth(getHealth()+10);
            System.out.println("狗狗现在和你的亲密度是："+getHealth());

        }
    }
}

子类猫咪：

package com.Polym;

public class Cat extends Pet {
    public void eat(){
        if(getIntimacy()<50){
            System.out.println("给猫咪吃猫粮和小鱼仔。。。。");
            setIntimacy(getIntimacy()+30);
            System.out.println("猫咪现在的健康值是："+getIntimacy());
            setHealth(getHealth()+10);
            System.out.println("猫咪现在和你的亲密度是："+getHealth());
        }
    }
}

主人类：

package com.Polym;

public class Master {
    public void  feed(Pet pet){
        if(pet instanceof Dog){
           pet.eat();
        }else if(pet instanceof Cat){
           pet.eat();
        }
    }
}

测试类：

public class Test {
    public static void main(String[] args){
        Master m1 = new Master();
        Dog P1 = new Dog();
        Cat P2 = new Cat();
        System.out.println("狗狗现在的健康值是："+P1.getIntimacy());
        System.out.println("狗狗现在和你的亲密度是："+P1.getHealth());
        m1.feed(P1);
        System.out.println("猫咪现在的健康值是："+P2.getIntimacy());
        System.out.println("猫咪现在和你的亲密度是："+P2.getHealth());
         m1.feed(P2); 
}
 }

输出结果图：

课堂笔记：

多态：
同一个引用类型，使用不同的实参执行不同操作
同一个类型使用不同的对象执行的结果有多种就是多态
一般就两种一种是父类作为参数，一种是父类作为反回值

继承，方法重写，父类引用指向子类对象，是实现多态的基础
1.使用多态时，是使用父类类型，但是对象还是子类对象
2.如果子类不重写父类方法，那么当使用多态时，是不能调用子类独有的方法
3.当子类重写父类方法，使用多态调用的方法，看似时父类的方法但实际调用的时子类中重写父类的那个方法，

一个方法没方法体就叫抽象方法
当一个类中有抽象方法的时候这个类就是抽象类，抽象类不一定有抽象方法，
抽象类不能被实列化，实列化没意义
抽象类的子类可以是普通类，该普通方法必须实现抽象类中抽象方法
抽象类的子类是抽象类时，此时可以不实现抽象类中抽象方法
抽象方法必须加关键词abstract
例： public abstract void a();

向上转型：
子类转化父类
父类型引用变量名 = new 子类型（）；自动转化类型
此时通过父类引用变量调用的方法是子类覆盖或继承父类的方法，不是父类本身的方法
此时通过父类引用变量无法调用子类特有的方法
向下转型：
父类转化子类
子类型引用变量名 = (子类型）父类的引用变量；需要强制类型转
实列方法：动态绑定机制调用属性和方法是子类中的
静态方法：静态绑定机制调用属性和方法是父类中的

代码下载链接：https://pan.baidu.com/s/1JBE5GSu7-Fd_i8pnGsYTng
提取码：ghzq

转载于:https://www.cnblogs.com/cxlbzdcom/p/10300851.html