题目：宠物医院管理系统业务需求及编程要求

业务背景

设计并实现一个宠物医院管理系统，该系统旨在帮助宠物医院高效管理各类业务，涵盖宠物信息管理、医疗服务管理、药品管理以及客户服务等多个方面。宠物医院接收不同种类的宠物，为它们提供全面的医疗保健服务，包括疾病诊断、治疗、疫苗接种等。同时，医院需要管理库存药品，记录客户信息和服务历史，以提供优质的客户体验。

宠物类型及属性

1. 猫（Cat）
   1. 名字（name）：例如 “布丁”“咪咪” 等，用于标识每只猫。
   2. 年龄（age）：以岁为单位，反映猫的生长阶段。
   3. 品种（breed）：如 “英国短毛猫”“暹罗猫” 等，区分不同的猫品种。
   4. 性别（gender）：公或母。
   5. 体重（weight）：以千克为单位，记录猫的体重信息。
   6. 毛色（color）：如 “白色”“黑色”“花色” 等。
   7. 功能：
      1. 喵喵叫（meow）：模拟猫发出叫声的行为。
      2. 玩耍（play）：模拟猫进行玩耍的动作。
2. 狗（Dog）
   1. 名字（name）：比如 “旺财”“拉布拉多” 等。
   2. 年龄（age）：单位为岁。
   3. 品种（breed）：像 “金毛寻回犬”“哈士奇” 等不同犬种。
   4. 性别（gender）：公或母。
   5. 体重（weight）：以千克为单位。
   6. 体型（size）：如 “小型”“中型”“大型”，描述狗的体型特征。
   7. 功能：
      1. 汪汪叫（bark）：模拟狗的叫声。
      2. 奔跑（run）：模拟狗奔跑的动作。
3. 兔子（Rabbit）
   1. 名字（name）：例如 “小白”“球球” 等。
   2. 年龄（age）：以月为单位，因为兔子生长速度相对较快。
   3. 品种（breed）：如 “垂耳兔”“荷兰兔” 等。
   4. 性别（gender）：公或母。
   5. 体重（weight）：以克为单位，记录兔子的体重。
   6. 毛色（color）：如 “灰色”“棕色” 等。
   7. 功能：
      1. 跳跃（jump）：模拟兔子跳跃的动作。
      2. 啃咬（gnaw）：模拟兔子啃咬东西的行为。

医院业务功能

1. 宠物信息管理
   1. 能够添加不同类型的宠物信息到系统中，记录宠物的基本属性，同时关联宠物主人的信息，如姓名、联系方式等。在添加宠物时，根据宠物类型自动匹配相应的属性录入模板，确保信息完整准确。
   2. 可以查询、修改和删除宠物信息。在查询时，支持根据宠物名字、品种、主人姓名等多种条件进行搜索，并能详细展示宠物的所有信息以及其医疗历史记录。
2. 医疗服务管理
   1. 记录宠物的诊断信息，包括疾病名称、症状描述、诊断日期等。针对不同的疾病，制定相应的治疗方案，记录治疗过程中使用的药品、治疗手段、治疗时间等详细信息。
   2. 提供医疗费用结算功能，根据治疗方案和使用的药品，计算出相应的费用，并记录费用支付情况。
3. 药品管理
   1. 记录药品的基本信息，如药品名称、规格、生产厂家、价格、保质期、库存数量等。
   2. 管理药品的采购和使用记录。在采购药品时，记录采购日期、供应商信息、采购数量等；在使用药品时，记录使用日期、使用在哪些宠物的治疗中以及使用数量等。

面向对象编程要求

1. 封装
   1. 将宠物的属性和操作封装在各自的类中，通过设置合理的访问权限（如 private、protected），隐藏内部实现细节。例如，宠物的体重属性设为 private，通过 public 的 getWeight () 和 setWeight () 方法来获取和修改体重，在 setWeight () 方法中可以添加体重合理性检查逻辑。
   2. 为每个宠物类封装特定的行为方法，如猫类的 meow () 和 play () 方法，狗类的 bark () 和 run () 方法等。同时，将医院业务功能相关的操作封装在对应的类中，如宠物信息管理类、医疗服务管理类等，每个类只对外提供必要的接口方法，保证系统的安全性和可维护性。
2. 继承
   1. 定义一个宠物抽象类，包含所有宠物共有的属性（如名字、年龄、性别）和抽象方法（如获取宠物基本信息、执行宠物行为）。每种具体的宠物类（猫、狗、兔子等）继承自宠物抽象类，继承其通用属性和方法，并根据自身特点重写抽象方法，实现个性化的功能。
   2. 对于医院业务功能类，也可以采用继承关系来实现代码复用。例如，医疗服务管理类和药品管理类可以继承自一个基础的管理类，该基础类包含一些通用的管理方法，如数据的添加、查询、修改等。
3. 多态
   1. 使用对象数组来管理不同类型的宠物，通过父类引用指向子类对象，实现多态性。在调用宠物的方法（如执行宠物行为、获取宠物基本信息）时，根据实际对象的类型动态调用相应子类的方法，而无需在代码中显式区分宠物类型。
   2. 在医院业务功能的实现中，充分利用多态性。例如，在计算医疗费用时，不同的治疗方案和药品使用情况可能会导致不同的费用计算方式，通过多态可以根据具体的治疗方案对象和药品对象动态调用相应的费用计算方法，实现统一的费用计算逻辑。

测试类要求

提供一个测试类，用于全面验证上述系统功能的正确性和稳定性。测试类应包含以下测试用例：

1. 测试宠物信息的添加、查询、修改和删除功能，检查信息是否准确记录和正确展示。
2. 测试医疗服务管理功能，包括诊断信息记录、治疗方案制定、疫苗接种记录管理和医疗费用结算等，验证功能是否正常运行，数据计算是否准确。
3. 测试药品管理功能，检查药品信息记录、库存预警、采购和使用记录管理等是否符合预期。
4. 针对多态性的测试，验证在不同宠物类型和业务场景下，多态方法的调用是否正确，结果是否符合预期。

通过以上测试用例的执行，全面检验宠物医院管理系统的各项功能，确保系统在实际应用中的可靠性和稳定性。

Pet类

public abstract class Pet {

    private String name;
    private int age;
    private String gender;

    public Pet(String name, int age, String gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public abstract String getInfo();
    public abstract void performAction();

}

Cat类

public class Cat extends Pet{

    private String breed;
    private double weight;
    private String color;

    public Cat(String name, int age, String gender, String breed, double weight, String color) {
        super(name, age, gender);
        this.breed = breed;
        this.weight = weight;
        this.color = color;
    }

    public double getWeight() {
        return weight;
    }

    public void setWeight(double weight) {
        if (weight > 0) {
            this.weight = weight;
        }
    }

    public void meow() {
        System.out.println(getName() + " 喵喵叫");
    }

    public void play() {
        System.out.println(getName() + " 在玩耍");
    }

    @Override
    public String getInfo() {
        return "猫名: " + getName() + ", 年龄: " + getAge() + " 岁, 品种: " + breed + ", 性别: " + getGender() + ", 体重: " + weight + " 千克, 毛色: " + color;
    }

    @Override
    public void performAction() {
        meow();
    }
}

Dog类

public class Dog extends Pet{

    private String breed;
    private double weight;
    private String size;

    public Dog(String name, int age, String gender, String breed, double weight, String size) {
        super(name, age, gender);
        this.breed = breed;
        this.weight = weight;
        this.size = size;
    }

    public double getWeight() {
        return weight;
    }

    public void setWeight(double weight) {
        if (weight > 0) {
            this.weight = weight;
        }
    }

    public void bark() {
        System.out.println(getName() + " 汪汪叫");
    }

    public void run() {
        System.out.println(getName() + " 在奔跑");
    }

    @Override
    public String getInfo() {
        return "狗名: " + getName() + ", 年龄: " + getAge() + " 岁, 品种: " + breed + ", 性别: " + getGender() + ", 体重: " + weight + " 千克, 体型: " + size;
    }

    @Override
    public void performAction() {
        bark();
    }

}

Rabbit类

public class Rabbit extends Pet{

    private String breed;
    private int weight;
    private String color;

    public Rabbit(String name, int age, String gender, String breed, int weight, String color) {
        super(name, age, gender);
        this.breed = breed;
        this.weight = weight;
        this.color = color;
    }

    public int getWeight() {
        return weight;
    }

    public void setWeight(int weight) {
        if (weight > 0) {
            this.weight = weight;
        }
    }

    public void jump() {
        System.out.println(getName() + " 在跳跃");
    }

    public void gnaw() {
        System.out.println(getName() + " 在啃咬");
    }

    @Override
    public String getInfo() {
        return "兔子名: " + getName() + ", 年龄: " + getAge() + " 月, 品种: " + breed + ", 性别: " + getGender() + ", 体重: " + weight + " 克, 毛色: " + color;
    }

    @Override
    public void performAction() {
        jump();
    }

}

PetOwner类 

public class PetOwner {

    private String name;
    private String contact;

    public PetOwner(String name, String contact) {
        this.name = name;
        this.contact = contact;
    }

    public String getName() {
        return name;
    }

    public String getContact() {
        return contact;
    }

}

PetInfoManagement类

public class PetInfoManagement {

    private Pet[] pets = new Pet[10];
    private PetOwner[] owners = new PetOwner[10];
    private int petCount = 0;

    public void addPet(Pet pet, PetOwner owner) {
        if (petCount < 10) {
            pets[petCount] = pet;
            owners[petCount] = owner;
            petCount++;
        }
    }

    //查询宠物
    public void queryPet(String keyword) {
        for (int i = 0; i < petCount; i++) {
            Pet pet = pets[i];
            PetOwner owner = owners[i];
            if (pet.getName().contains(keyword) || pet.getInfo().contains(keyword) || owner.getName().contains(keyword)) {
                System.out.println(pet.getInfo() + ", 主人: " + owner.getName() + ", 联系方式: " + owner.getContact());
                return;
            }
        }
        System.out.println("未找到该宠物！");
    }

    //修改宠物信息：旧宠物信息，新宠物信息
    public void modifyPet(Pet oldPet, Pet newPet) {
        for (int i = 0; i < petCount; i++) {
            if (pets[i] == oldPet) {
                pets[i] = newPet;
                break;
            }
        }
    }

    //删除宠物
    public void deletePet(Pet pet) {
        for (int i = 0; i < petCount; i++) {
            if (pets[i] == pet) {
                for (int j = i; j < petCount - 1; j++) {
                    pets[j] = pets[j + 1];
                    owners[j] = owners[j + 1];
                }
                petCount--;
                break;
            }
        }
    }

}

Medicine类

public class Medicine {

    private String name;
    private String specification;
    private String manufacturer;
    private double price;
    private String expirationDate;
    private int stock;

    public Medicine(String name, String specification, String manufacturer, double price, String expirationDate, int stock) {
        this.name=name;
        this.specification=specification;
        this.manufacturer=manufacturer;
        this.price=price;
        this.expirationDate=expirationDate;
        this.stock=stock;
    }

    public String getName() {
        return name;
    }

    public String getSpecification() {
        return specification;
    }

    public void setSpecification(String specification) {
        this.specification=specification;
    }

    public String getManufacturer() {
        return manufacturer;
    }

    public void setManufacturer(String manufacturer) {
        this.manufacturer=manufacturer;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price=price;
    }

    public String getExpirationDate() {
        return expirationDate;
    }

    public void setExpirationDate(String expirationDate) {
        this.expirationDate=expirationDate;
    }

    public int getStock() {
        return stock;
    }

    public void setStock(int stock) {
        this.stock=stock;
    }

    //药品管理系统
    static class MedicineManagement {
        private Medicine[] medicines=new Medicine[10];
        private String[] purchaseRecords=new String[10];
        private String[] usageRecords=new String[10];
        private int medicineCount=0;


        //添加药品
        public void addMedicine(Medicine medicine) {
            if (medicineCount < 10) {
                medicines[medicineCount]=medicine;
                medicineCount++;
            }
        }

        //药品库存信息
        public void medicineShow(){
            for (int i=0; i < medicineCount; i++) {
                if (medicines[i] != null){
                    System.out.println("药品："+medicines[i].getName()+"，规格："+medicines[i].getSpecification()+"，生产厂商："+medicines[i].getManufacturer()+
                            "，价格："+medicines[i].getPrice()+"，有效期至："+medicines[i].getExpirationDate()+"，库存："+medicines[i].getStock());
                }
            }
        }

        //采购药品库存信息
        public void purchaseMedicine(Medicine medicine, int quantity, String supplier, String date) {
            for (int i=0; i < medicineCount; i++) {
                if (medicines[i] == medicine) {
                    medicine.setStock(medicine.getStock() + quantity);
                    purchaseRecords[i]="采购日期: " + date + ", 供应商: " + supplier + ", 药品: " + medicine.getName() + ", 数量: " + quantity;
                    break;
                }
            }
        }

        public void purchaseMedicineShow(){
            for (int i=0; i < medicineCount; i++) {
                if (purchaseRecords[i] != null){
                    System.out.println(purchaseRecords[i]);
                }
            }
        }

        //使用药品具体信息
        public void useMedicine(Medicine medicine, int quantity, String petName, String date) {
            for (int i=0; i < medicineCount; i++) {
                if (medicines[i] == medicine && medicine.getStock() >= quantity) {
                    medicine.setStock(medicine.getStock() - quantity);
                    usageRecords[i]="使用日期: " + date + ", 宠物: " + petName + ", 药品: " + medicine.getName() + ", 数量: " + quantity;
                    break;
                }
            }
        }

        public void useMedicineShow(){
            for (int i=0; i < medicineCount; i++) {
                if (usageRecords[i] != null){
                    System.out.println(usageRecords[i]);
                }
            }
        }
    }
}

MedicalServiceManagement类

public class MedicalServiceManagement {
    private String[] diagnosisInfo = new String[10];
    private String[] treatmentPlans = new String[10];
    private double[] costs = new double[10];
    private boolean[] paymentStatus = new boolean[10];
    private int recordCount = 0;

    //记录诊断信息
    public void recordDiagnosis(String diagnosis) {
        if (recordCount < 10) {
            diagnosisInfo[recordCount] = diagnosis;
            recordCount++;
        }
    }

    //治疗方案制定
    public void makeTreatmentPlan(String plan) {
        if (recordCount < 10) {
            treatmentPlans[recordCount - 1] = plan;
        }
    }

    //费用结算
    public void calculateCost(double cost) {
        if (recordCount < 10) {
            costs[recordCount - 1] = cost;
        }
    }

    //记录费用是否缴纳
    public void recordPayment(boolean paid) {
        if (recordCount < 10) {
            paymentStatus[recordCount - 1] = paid;
        }
    }

    public void show(){
        for (int i=0; i < diagnosisInfo.length; i++) {
            if (diagnosisInfo[i] != null){
                System.out.println("宠物情况："+diagnosisInfo[i]);
                System.out.println("治疗预案："+treatmentPlans[i]);
                System.out.println("费用结算："+costs[i]);
                System.out.println("是否缴纳费用："+ (paymentStatus[i] ? "已缴纳" : "未缴纳"));
            }
        }
    }
}

Test

public class Test {

    public static void main(String[] args) {

        // 测试宠物信息管理
        System.out.println("=============测试宠物信息管理===========");
        PetInfoManagement petInfoManagement = new PetInfoManagement();
        //添加主人和猫咪信息
        PetOwner owner1 = new PetOwner("张三", "13800138000");
        Cat cat = new Cat("布丁", 2, "母", "英国短毛猫", 3.5, "白色");
        Dog dog = new Dog("大黄", 3, "母", "中华田园犬", 6, "50");
        petInfoManagement.addPet(cat, owner1);
        petInfoManagement.addPet(dog, owner1);
        //查询宠物信息
        System.out.println("+查询宠物信息+");
        petInfoManagement.queryPet("布丁");
        petInfoManagement.queryPet("大黄");
        System.out.println("========================");
        //修改猫咪信息
        System.out.println("+修改猫咪信息+");
        Cat newCat = new Cat("布丁", 3, "母", "英国短毛猫", 4.0, "白色");
        petInfoManagement.modifyPet(cat, newCat);
        petInfoManagement.queryPet("布丁");
        //删除宠物
        System.out.println("+删除猫咪信息+");
        petInfoManagement.deletePet(newCat);
        petInfoManagement.queryPet("布丁");

        System.out.println("====================================================================================================");

        // 测试医疗服务管理
        System.out.println("=============测试医疗服务管理===========");
        MedicalServiceManagement medicalServiceManagement = new MedicalServiceManagement();
        medicalServiceManagement.recordDiagnosis("感冒，症状：流鼻涕，诊断日期：2025-04-13");
        medicalServiceManagement.makeTreatmentPlan("使用感冒药，每天两次，每次一片，治疗时间：一周");
        medicalServiceManagement.calculateCost(50.0);
        medicalServiceManagement.recordPayment(true);
        medicalServiceManagement.show();

        System.out.println("========================");

        MedicalServiceManagement medicalServiceManagement1 = new MedicalServiceManagement();
        medicalServiceManagement1.recordDiagnosis("感冒，症状：流鼻涕，诊断日期：2025-03-13");
        medicalServiceManagement1.makeTreatmentPlan("使用感冒药，每天两次，每次一片，治疗时间：一个月");
        medicalServiceManagement1.calculateCost(1500.0);
        medicalServiceManagement1.recordPayment(false);
        medicalServiceManagement1.show();

        System.out.println("====================================================================================================");

        // 测试药品管理
        System.out.println("=============测试药品管理===========");
        Medicine.MedicineManagement medicineManagement = new Medicine.MedicineManagement();
        Medicine medicine = new Medicine("感冒药", "10片/盒", "徐州药厂", 20.0, "2026-01-01", 10);
        Medicine medicine1 = new Medicine("发烧药", "15片/盒", "徐州药厂", 120.0, "2027-01-01", 30);
        //添加药品
        System.out.println("+添加药品+");
        medicineManagement.addMedicine(medicine);
        medicineManagement.addMedicine(medicine1);
        medicineManagement.medicineShow();
        System.out.println("========================");
        //购买药品
        System.out.println("+购买药品+");
        medicineManagement.purchaseMedicine(medicine, 5, "海澜之家", "2025-04-13");
        medicineManagement.purchaseMedicineShow();
        medicineManagement.medicineShow();
        System.out.println("========================");
        //使用药品
        System.out.println("+使用药品+");
        medicineManagement.useMedicine(medicine, 2, "布丁", "2025-04-13");
        medicineManagement.useMedicineShow();
        medicineManagement.medicineShow();

        System.out.println("====================================================================================================");

        // 测试多态
        Pet[] pets = new Pet[3];
        pets[0] = new Cat("咪咪", 1, "公", "暹罗猫", 2.5, "花色");
        pets[1] = new Dog("旺财", 3, "公", "金毛寻回犬", 20.0, "大型");
        pets[2] = new Rabbit("小白", 6, "母", "垂耳兔", 1500, "白色");
        for (Pet pet : pets) {
            pet.performAction();
            System.out.println(pet.getInfo());
        }

    }
}

预输出结果：