课程-信创智能医疗软件研发-计算机程序设计

【2023级】智能医学工程专业-计算机程序设计-第09章-类与对象

作者:阮晓龙发布时间:2024/9/13 13:16:33

基本信息：

章节名称：智能医学工程专业-计算机程序设计-第09章-类与对象
授课教师：信息技术学院互联网技术教学团队
完成时间：2024年09月
适用年级：2023级
适用专业：智能医学工程

文档内容：

讲稿课件（教学版）：智能医学工程-计算机程序设计-课件-第09章-类与对象-教学版.pdf
讲稿课件（笔记版）：智能医学工程-计算机程序设计-课件-第09章-类与对象-笔记版.pdf
讲稿课件（在线版）：

学习资源：

代码：eg9.1

// 定义一个简单的类
class Person {
    // 属性
    String name;
    int age;
 
    // 方法
    void speak() {
        System.out.println("Hello, my name is " + name + " and I am " + age + " years old.");
    }
}
 
public class Main {
    public static void main(String[] args) {
        // 创建一个Person对象
        Person person = new Person();
        
        // 设置属性
        person.name = "Alice";//直接访问成员变量?
        person.age = 30;//直接访问成员变量?
        
        // 调用方法
        person.speak();
    }
}

代码：eg9.1.1

public class Dog {
    String breed;
    int size;
    String colour;
    int age;
 
    void eat() {
    }
 
    void run() {
    }
 
    void sleep(){
    }
 
}

代码：eg9.1.1-2

public class Puppy{
    public Puppy(){
        // 这个构造器没有参数
    }
 
    public Puppy(String name){
        // 这个构造器仅有一个参数：name
    }
}

代码：eg9.1.1-3

public class Puppy{
   public Puppy(String name){
      //这个构造器仅有一个参数：name
      System.out.println("小狗的名字是 : " + name ); 
   }
   public static void main(String[] args){
      // 下面的语句将创建一个Puppy对象
      Puppy myPuppy = new Puppy( "tommy" );
   }
}

代码：eg9.1.1-4

public class Puppy {
    private int age;
    private String name;
 
    // 构造器
    public Puppy(String name) {
        this.name = name;
        System.out.println("小狗的名字是 : " + name);
    }
 
    // 设置 age 的值
    public void setAge(int age) {
        this.age = age;
    }
 
    // 获取 age 的值
    public int getAge() {
        return age;
    }
 
    // 获取 name 的值
    public String getName() {
        return name;
    }
 
    // 主方法
    public static void main(String[] args) {
        // 创建对象
        Puppy myPuppy = new Puppy("Tommy");
 
        // 通过方法来设定 age
        myPuppy.setAge(2);
 
        // 调用另一个方法获取 age
        int age = myPuppy.getAge();
        System.out.println("小狗的年龄为 : " + age);
 
        // 也可以直接访问成员变量（通过 getter 方法）
        System.out.println("变量值 : " + myPuppy.getAge());
    }
}

代码：eg9.1.1-5

import java.io.*;
 
public class Employee {
    private String name;
    private int age;
    private String designation;
    private double salary;
 
    // Employee 类的构造器
    public Employee(String name) {
        this.name = name;
    }
 
    // 设置 age 的值
    public void setAge(int age) {
        this.age = age;
    }
 
    // 获取 age 的值
    public int getAge() {
        return age;
    }
 
    // 设置 designation 的值
    public void setDesignation(String designation) {
        this.designation = designation;
    }
 
    // 获取 designation 的值
    public String getDesignation() {
        return designation;
    }
 
    // 设置 salary 的值
    public void setSalary(double salary) {
        this.salary = salary;
    }
 
    // 获取 salary 的值
    public double getSalary() {
        return salary;
    }
 
    // 打印信息
    public void printEmployee() {
        System.out.println(this);
    }
 
    // 重写 toString 方法
    @Override
    public String toString() {
        return "名字: " + name + "\n" +
               "年龄: " + age + "\n" +
               "职位: " + designation + "\n" +
               "薪水: " + salary;
    }
}

代码：9.1.1-6

import java.io.*;
 
public class EmployeeTest {
    public static void main(String[] args) {
        // 使用构造器创建两个对象
        Employee empOne = new Employee("RUNOOB1");
        Employee empTwo = new Employee("RUNOOB2");
 
        // 调用这两个对象的成员方法
        empOne.setAge(26);
        empOne.setDesignation("高级程序员");
        empOne.setSalary(1000);
        empOne.printEmployee();
 
        empTwo.setAge(21);
        empTwo.setDesignation("菜鸟程序员");
        empTwo.setSalary(500);
        empTwo.printEmployee();
    }
}

//Employee
//......
//......

代码：eg9.2

// 假设有一个简单的用户类
public class User {
    private String name;
    private int age;
 
    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }
 
    public String getName() {
        return name;
    }
 
    public int getAge() {
        return age;
    }
}
 
// 假设有一个简单的用户存储类
import java.util.HashMap;
import java.util.Map;
 
public class UserRepository {
    private Map<String, User> users = new HashMap<>();
 
    public void addUser(String id, User user) {
        users.put(id, user);
    }
 
    public User getUser(String id) {
        return users.get(id);
    }
}
 
// 假设有一个简单的用户服务类
public class UserService {
    private UserRepository userRepository = new UserRepository();
 
    public void addUser(String id, String name, int age) {
        User user = new User(name, age);
        userRepository.addUser(id, user);
    }
 
    public User getUser(String id) {
        return userRepository.getUser(id);
    }
}
 
// 假设有一个用于测试的类
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;

//我们引入了junit
public class UserServiceTest {
    @Test
    public void whenAddUser_thenGetUser() {
        UserService userService = new UserService();
        userService.addUser("1", "Alice", 25);
        User user = userService.getUser("1");
        assertEquals("Alice", user.getName());
        assertEquals(25, user.getAge());
    }

//我们还可以使用main
//...
}

代码：eg9.2.1

// 功能接口定义
public interface Feature {
    void execute();
}
 
// 功能实现类A
public class FeatureA implements Feature {
    @Override
    public void execute() {
        // 实现具体功能
        System.out.println("Feature A is executed.");
    }
}
 
// 功能实现类B
public class FeatureB implements Feature {
    @Override
    public void execute() {
        // 实现具体功能
        System.out.println("Feature B is executed.");
    }
}
 
// 系统架构类
public class SystemArchitecture {
    private List<Feature> features = new ArrayList<>();
 
    public SystemArchitecture(List<Feature> features) {
        this.features = features;
    }
 
    public void runAllFeatures() {
        for (Feature feature : features) {
            feature.execute();
        }
    }
}
 
// 使用示例
public class Main {
    public static void main(String[] args) {
        List<Feature> featureList = Arrays.asList(new FeatureA(), new FeatureB());
        SystemArchitecture architecture = new SystemArchitecture(featureList);
        architecture.runAllFeatures();
    }
}

代码：eg9.2.2

// 假设我们有一个简单的类，用于表示用户的信用卡信息
public class CreditCard {
    private String number;
    private double balance;
 
    // 构造函数，用于创建新的信用卡实例
    public CreditCard(String number, double balance) {
        this.number = number;
        this.balance = balance;
    }
 
    // 获取信用卡号的方法
    public String getNumber() {
        return number;
    }
 
    // 获取余额的方法
    public double getBalance() {
        return balance;
    }
 
    // 更新余额的方法
    public void updateBalance(double amount) {
        this.balance += amount;
    }
 
    // 打印信用卡信息的方法
    public void printCardInfo() {
        System.out.println("信用卡号: " + number);
        System.out.println("余额: " + balance);
    }
}
 
// 使用示例
public class CreditCardExample {
    public static void main(String[] args) {
        // 创建一个信用卡实例
        CreditCard myCard = new CreditCard("1234-5678-9101-1213", 5000.00);
 
        // 打印信用卡信息
        myCard.printCardInfo();
 
        // 更新余额
        myCard.updateBalance(1000.00);
 
        // 再次打印信用卡信息
        myCard.printCardInfo();
    }
}

代码：eg9.3

public class Person {
    // 属性，也称为实例变量
    private String name;
    private int age;
 
    // 构造器，用于创建对象时初始化实例变量
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
 
    // 方法，用于定义对象的行为
    public void introduce() {
        System.out.println("My name is " + name + " and I am " + age + " years old.");
    }
}
 
// 使用Person类创建一个对象并调用其方法
public class Main {
    public static void main(String[] args) {
        Person person = new Person("Alice", 30); // 创建Person对象
        person.introduce(); // 调用对象的方法
    }
}

代码：eg9.4

// 假设我们正在处理一个关于游戏内购物品的问题
// 以下是一个简化的类设计，用于表示游戏内的物品
 
// 游戏物品类型枚举
public enum ItemType {
    CONSUMABLE, // 可消费物品，如宝石、体力等
    CURRENCY,   // 货币类物品，如金币
    BOOSTER     // 物品增强类型
}
 
// 游戏物品基类
public abstract class GameItem {
    private String name;
    private ItemType type;
 
    public GameItem(String name, ItemType type) {
        this.name = name;
        this.type = type;
    }
 
    public String getName() {
        return name;
    }
 
    public ItemType getType() {
        return type;
    }
 
    // 抽象方法，由子类实现以描述物品的效果
    public abstract String describeEffect();
}
 
// 可消费物品类
public class ConsumableItem extends GameItem {
    public ConsumableItem(String name) {
        super(name, ItemType.CONSUMABLE);
    }
 
    @Override
    public String describeEffect() {
        return "这是一个可消耗的物品，它可以给玩家带来积极的效果。";
    }
}
 
// 货币类物品类
public class CurrencyItem extends GameItem {
    private int amount;
 
    public CurrencyItem(String name, int amount) {
        super(name, ItemType.CURRENCY);
        this.amount = amount;
    }
 
    @Override
    public String describeEffect() {
        return "获得 " + amount + " 金币。";
    }
}
 
// 物品增强类型
public class BoosterItem extends GameItem {
    private int duration; // 持续时间
 
    public BoosterItem(String name, int duration) {
        super(name, ItemType.BOOSTER);
        this.duration = duration;
    }
 
    @Override
    public String describeEffect() {
        return "提供短暂的属性加成，持续 " + duration + " 小时。";
    }
}
 
// 使用示例
public class Main {
    public static void main(String[] args) {
        GameItem item = new ConsumableItem("治疗药水");
        System.out.println(item.getName() + ": " + item.describeEffect());
 
        item = new CurrencyItem("宝石", 1000);
        System.out.println(item.getName() + ": " + item.describeEffect());
 
        item = new BoosterItem("力量加成", 2);
        System.out.println(item.getName() + ": " + item.describeEffect());
    }
}

代码：eg9.5

public class Patient {
    private String patientId;
    private String name;
    private int age;
    private String gender;
    private String address;
 
    // 构造函数
    public Patient(String patientId, String name, int age, String gender, String address) {
        this.patientId = patientId;
        this.name = name;
        this.age = age;
        this.gender = gender;
        this.address = address;
    }
 
    // Getter和Setter方法
    public String getPatientId() {
        return patientId;
    }
 
    public void setPatientId(String patientId) {
        this.patientId = patientId;
    }
 
    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 String getAddress() {
        return address;
    }
 
    public void setAddress(String address) {
        this.address = address;
    }
 
    // 可以添加更多的病患相关信息和方法
}

代码：eg9.5.1

public class MedicalService {
    private String serviceId; // 服务ID
    private String serviceName; // 服务名称
    private String serviceType; // 服务类型
    private String serviceDescription; // 服务描述
    private double servicePrice; // 服务价格
 
    // 构造函数
    public MedicalService(String serviceId, String serviceName, String serviceType, String serviceDescription, double servicePrice) {
        this.serviceId = serviceId;
        this.serviceName = serviceName;
        this.serviceType = serviceType;
        this.serviceDescription = serviceDescription;
        this.servicePrice = servicePrice;
    }
 
    // 省略getter和setter方法...
}

代码：eg9.5.2

// 定义一个基础的医疗保健服务类
public class MedicalService {
    private String serviceName;
    private String serviceDescription;
 
    // 构造函数
    public MedicalService(String name, String description) {
        this.serviceName = name;
        this.serviceDescription = description;
    }
 
    // 获取服务名称
    public String getServiceName() {
        return serviceName;
    }
 
    // 获取服务描述
    public String getServiceDescription() {
        return serviceDescription;
    }
}
 
// 定义一个医疗服务的子类：检查
public class MedicalCheckupService extends MedicalService {
    public MedicalCheckupService(String name, String description) {
        super(name, description);
    }
 
    // 可以添加检查相关的方法和属性
}
 
// 使用示例
public class Example {
    public static void main(String[] args) {
        MedicalService service = new MedicalService("常规检查", "检查患者的基本健康状况");
        MedicalCheckupService checkupService = new MedicalCheckupService("血常规检查", "检查患者的血液样本");
 
        System.out.println("服务名称: " + service.getServiceName());
        System.out.println("服务描述: " + service.getServiceDescription());
 
        System.out.println("检查服务名称: " + checkupService.getServiceName());
        // 添加其他检查服务的描述或属性
    }
}

软件资源：