• Java基础 - 模拟医院挂号系统

    模拟医院挂号系统功能

    1. 科室管理：新增科室，删除科室（如果有医生在，则不能删除该科室），修改科室

    2. 医生管理：录入医生信息以及科室信息，修改医生信息（主要是修改个人信息和科室）

    3. 坐诊信息设置：可以设置医生当天和未来6天的坐诊情况，包括上午和下午的坐诊时间段和可预约数量，系统将自动保存到该医生的坐诊信息列表中

    4. 全部信息展示：按照科室，展示每个医生七天的坐诊情况，需要按照科室归类展示

    5. 预约功能：用户可以选择要预约的科室，医生、日期和时间段，并输入患者的个人信息，系统将激动判断该时间段是否还有预约名额，并保存预约信息

    6. 搜索功能：用户可以输入搜索日期和时间段，系统将自动搜索未来七天内在该时间段坐诊的医生信息，并按照科室分类展示

    7. 可以查询某个医生未来7天，病人对他的预约情况

    1. //App
    2. public class App {
    3.     public static void main(String[] args) {
    4.         //创建一个医院管理对象
    5.         HospitalManager h = new HospitalManager();
    6.         h.start();
    7.     }
    8. }
    1. //Doctor
    2. //医生类
    3. public class Doctor {
    4.     private String doctorId;  //编号（唯一）
    5.     private String name;  //姓名
    6.     private String departmentName;  //科室名称
    7.     private String gender;  //性别
    8.     private int age;  //年龄
    9.     private String specialty;  //主治方向
    10.     private LocalDate joinDate;  //入职时间
    11.     private ArrayList schedules = new ArrayList<>();  //7天坐诊情况
    12.  
    13.     public Doctor() {
    14.     }
    15.  
    16.     public Doctor(String doctorId, String name, String departmentName, String gender, int age, String specialty, LocalDate joinDate, ArrayList schedules) {
    17.         this.doctorId = doctorId;
    18.         this.name = name;
    19.         this.departmentName = departmentName;
    20.         this.gender = gender;
    21.         this.age = age;
    22.         this.specialty = specialty;
    23.         this.joinDate = joinDate;
    24.         this.schedules = schedules;
    25.     }
    26.  
    27.     public String getDoctorId() {
    28.         return doctorId;
    29.     }
    30.  
    31.     public void setDoctorId(String doctorId) {
    32.         this.doctorId = doctorId;
    33.     }
    34.  
    35.     public String getName() {
    36.         return name;
    37.     }
    38.  
    39.     public void setName(String name) {
    40.         this.name = name;
    41.     }
    42.  
    43.     public String getDepartmentName() {
    44.         return departmentName;
    45.     }
    46.  
    47.     public void setDepartmentName(String departmentName) {
    48.         this.departmentName = departmentName;
    49.     }
    50.  
    51.     public String getGender() {
    52.         return gender;
    53.     }
    54.  
    55.     public void setGender(String gender) {
    56.         this.gender = gender;
    57.     }
    58.  
    59.     public int getAge() {
    60.         return age;
    61.     }
    62.  
    63.     public void setAge(int age) {
    64.         this.age = age;
    65.     }
    66.  
    67.     public String getSpecialty() {
    68.         return specialty;
    69.     }
    70.  
    71.     public void setSpecialty(String specialty) {
    72.         this.specialty = specialty;
    73.     }
    74.  
    75.     public LocalDate getJoinDate() {
    76.         return joinDate;
    77.     }
    78.  
    79.     public void setJoinDate(LocalDate joinDate) {
    80.         this.joinDate = joinDate;
    81.     }
    82.  
    83.     public ArrayList getSchedules() {
    84.         return schedules;
    85.     }
    86.  
    87.     public void setSchedules(ArrayList schedules) {
    88.         this.schedules = schedules;
    89.     }
    90. }
    1. //Department
    2. //科室类
    3. public class Department {
    4.     private String name;
    5.     private ArrayList doctors = new ArrayList<>();
    6.  
    7.     public Department() {
    8.     }
    9.  
    10.     public Department(String name, ArrayList doctors) {
    11.         this.name = name;
    12.         this.doctors = doctors;
    13.     }
    14.  
    15.     public String getName() {
    16.         return name;
    17.     }
    18.  
    19.     public void setName(String name) {
    20.         this.name = name;
    21.     }
    22.  
    23.     public ArrayList getDoctors() {
    24.         return doctors;
    25.     }
    26.  
    27.     public void setDoctors(ArrayList doctors) {
    28.         this.doctors = doctors;
    29.     }
    30. }
    1. //Schedule
    2. //医生坐诊情况类
    3. public class Schedule {
    4.     private LocalDate today;  //当天日期
    5.     private boolean update = false;  //是否排班（默认未排班false）
    6.     //上午
    7.     private boolean morning;  //是否看诊
    8.     private LocalTime mStart;  //上午开始时间
    9.     private LocalTime mEnd;  //上午结束时间
    10.     private int mTotalNum;  //上午可预约人数
    11.     private int mAppointNum;  //上午已预约人数
    12.  
    13.     //下午
    14.     private boolean afternoon;  //是否看诊
    15.     private LocalTime aStart;  //下午开始时间
    16.     private LocalTime aEnd;  //下午结束时间
    17.     private int aTotalNum;  //下午可预约人数
    18.     private int aAppointNum;  //下午已预约人数
    19.  
    20.     public Schedule() {
    21.     }
    22.  
    23.     public Schedule(LocalDate today, boolean update, boolean morning, LocalTime mStart, LocalTime mEnd, int mTotalNum, int mAppointNum, boolean afternoon, LocalTime aStart, LocalTime aEnd, int aTotalNum, int aAppointNum) {
    24.         this.today = today;
    25.         this.update = update;
    26.         this.morning = morning;
    27.         this.mStart = mStart;
    28.         this.mEnd = mEnd;
    29.         this.mTotalNum = mTotalNum;
    30.         this.mAppointNum = mAppointNum;
    31.         this.afternoon = afternoon;
    32.         this.aStart = aStart;
    33.         this.aEnd = aEnd;
    34.         this.aTotalNum = aTotalNum;
    35.         this.aAppointNum = aAppointNum;
    36.     }
    37.  
    38.     public boolean isUpdate() {
    39.         return update;
    40.     }
    41.  
    42.     public void setUpdate(boolean update) {
    43.         this.update = update;
    44.     }
    45.  
    46.     public LocalDate getToday() {
    47.         return today;
    48.     }
    49.  
    50.     public void setToday(LocalDate today) {
    51.         this.today = today;
    52.     }
    53.  
    54.     public boolean isMorning() {
    55.         return morning;
    56.     }
    57.  
    58.     public void setMorning(boolean morning) {
    59.         this.morning = morning;
    60.     }
    61.  
    62.     public LocalTime getmStart() {
    63.         return mStart;
    64.     }
    65.  
    66.     public void setmStart(LocalTime mStart) {
    67.         this.mStart = mStart;
    68.     }
    69.  
    70.     public LocalTime getmEnd() {
    71.         return mEnd;
    72.     }
    73.  
    74.     public void setmEnd(LocalTime mEnd) {
    75.         this.mEnd = mEnd;
    76.     }
    77.  
    78.     public int getmTotalNum() {
    79.         return mTotalNum;
    80.     }
    81.  
    82.     public void setmTotalNum(int mTotalNum) {
    83.         this.mTotalNum = mTotalNum;
    84.     }
    85.  
    86.     public int getmAppointNum() {
    87.         return mAppointNum;
    88.     }
    89.  
    90.     public void setmAppointNum(int mAppointNum) {
    91.         this.mAppointNum = mAppointNum;
    92.     }
    93.  
    94.     public boolean isAfternoon() {
    95.         return afternoon;
    96.     }
    97.  
    98.     public void setAfternoon(boolean afternoon) {
    99.         this.afternoon = afternoon;
    100.     }
    101.  
    102.     public LocalTime getaStart() {
    103.         return aStart;
    104.     }
    105.  
    106.     public void setaStart(LocalTime aStart) {
    107.         this.aStart = aStart;
    108.     }
    109.  
    110.     public LocalTime getaEnd() {
    111.         return aEnd;
    112.     }
    113.  
    114.     public void setaEnd(LocalTime aEnd) {
    115.         this.aEnd = aEnd;
    116.     }
    117.  
    118.     public int getaTotalNum() {
    119.         return aTotalNum;
    120.     }
    121.  
    122.     public void setaTotalNum(int aTotalNum) {
    123.         this.aTotalNum = aTotalNum;
    124.     }
    125.  
    126.     public int getaAppointNum() {
    127.         return aAppointNum;
    128.     }
    129.  
    130.     public void setaAppointNum(int aAppointNum) {
    131.         this.aAppointNum = aAppointNum;
    132.     }
    133. }
    1. //Appointment
    2. //患者预约信息类
    3. public class Appointment {
    4.     private String userName;  //患者姓名
    5.     private String sex;  //患者性别
    6.     private int age;  //患者年龄
    7.     private String tel;  //患者电话
    8.     private String desc;  //病情描述
    9.     private String departmentName;  //挂号科室
    10.     private String doctorId;  //看诊医生id
    11.     private LocalDateTime appointDateTime;  //预约时间
    12.  
    13.     public Appointment() {
    14.     }
    15.  
    16.  
    17.     public String getUserName() {
    18.         return userName;
    19.     }
    20.  
    21.     public void setUserName(String userName) {
    22.         this.userName = userName;
    23.     }
    24.  
    25.     public String getSex() {
    26.         return sex;
    27.     }
    28.  
    29.     public void setSex(String sex) {
    30.         this.sex = sex;
    31.     }
    32.  
    33.     public int getAge() {
    34.         return age;
    35.     }
    36.  
    37.     public void setAge(int age) {
    38.         this.age = age;
    39.     }
    40.  
    41.     public String getTel() {
    42.         return tel;
    43.     }
    44.  
    45.     public void setTel(String tel) {
    46.         this.tel = tel;
    47.     }
    48.  
    49.     public String getDesc() {
    50.         return desc;
    51.     }
    52.  
    53.     public void setDesc(String desc) {
    54.         this.desc = desc;
    55.     }
    56.  
    57.     public String getDepartmentName() {
    58.         return departmentName;
    59.     }
    60.  
    61.     public void setDepartmentName(String departmentName) {
    62.         this.departmentName = departmentName;
    63.     }
    64.  
    65.     public String getDoctorId() {
    66.         return doctorId;
    67.     }
    68.  
    69.     public void setDoctorId(String doctorId) {
    70.         this.doctorId = doctorId;
    71.     }
    72.  
    73.     public LocalDateTime getAppointDateTime() {
    74.         return appointDateTime;
    75.     }
    76.  
    77.     public void setAppointDateTime(LocalDateTime appointDateTime) {
    78.         this.appointDateTime = appointDateTime;
    79.     }
    80. }
    1. /*
    2.     模拟医院挂号系统功能
    3.         1. 科室管理：新增科室，删除科室（如果有医生在，则不能删除该科室），修改科室名称
    4.         2. 医生管理：录入医生信息以及科室信息，修改医生信息（主要是修改个人信息和科室）
    5.         3. 坐诊信息设置：可以设置医生当天和未来6天的坐诊情况，包括上午和下午的坐诊时间段和可预约数量，系统将自动保存到该医生的坐诊信息列表中
    6.         4. 全部信息展示：按照科室，展示每个医生七天的坐诊情况，需要按照科室归类展示
    7.         5. 预约功能：用户可以选择要预约的科室，医生、日期和时间段，并输入患者的个人信息，系统将激动判断该时间段是否还有预约名额，并保存预约信息
    8.         6. 搜索功能：用户可以输入搜索日期和时间段，系统将自动搜索未来七天内在该时间段坐诊的医生信息，并按照科室分类展示
    9.         7. 可以查询某个医生未来7天，病人对他的预约情况
    10. */
    11.  
    12. //HospitalManager
    13. public class HospitalManager {
    14.     //系统需要存储全部科室信息
    15.     private ArrayList departments = new ArrayList<>();
    16.  
    17.     //系统需要记录全部预约信息
    18.     private ArrayList appointments = new ArrayList<>();
    19.  
    20.     Scanner sc = new Scanner(System.in);
    21.  
    22.     public void start() {
    23.         while(true){
    24.             System.out.println("====欢迎进入莴笋医院信息管理系统====");
    25.             System.out.println("====1.科室管理--添加科室====");
    26.             System.out.println("====2.科室管理--删除科室====");
    27.             System.out.println("====3.科室管理--修改科室名称====");
    28.             System.out.println("====4.医生管理--录入医生====");
    29.             System.out.println("====5.医生管理--医生坐诊设置（可设置当天和未来6天的坐诊情况）====");
    30.             System.out.println("====6.搜索--查看全部医生坐诊情况（当天和未来6天的坐诊详情）====");
    31.             System.out.println("====7.搜索--查看某医生坐诊情况（当天和未来6天的坐诊详情）====");
    32.             System.out.println("====8.挂号--挂号预约====");
    33.             System.out.println("====9.退出====");
    34.             System.out.println("请输入您的操作指令（1-9）：");
    35.             switch (sc.next()){
    36.                 case "1":
    37.                     addDepartment();
    38.                     break;
    39.                 case "2":
    40.                     deleteDepartment();
    41.                     break;
    42.                 case "3":
    43.                     modifyDepartment();
    44.                     break;
    45.                 case "4":
    46.                     addDoctor();
    47.                     break;
    48.                 case "5":
    49.                     setDoctorJob();
    50.                     break;
    51.                 case "6":
    52.                     searchAllJob();
    53.                     break;
    54.                 case "7":
    55.                     searchOneJob();
    56.                     break;
    57.                 case "8":
    58.                     Appoint();
    59.                     break;
    60.                 case "9":
    61.                     return;
    62.                 default:
    63.                     System.out.println("您选择的操作不存在，请重新选择");
    64.                     break;
    65.             }
    66.         }
    67.     }
    68.  
    69.     private void Appoint() {
    70.         System.out.println("====挂号预约====");
    71.         //判断有没有科室（医院没有科室就一定没有医生）
    72.         if(isDepartment()==false) {
    73.             System.out.println("没有科室就没有医生");
    74.             return;
    75.         }
    76.  
    77.         //有科室
    78.         while(true) {
    79.             showAllDepartment();  //展示已有科室
    80.             //先选择科室
    81.             System.out.println("请选择挂号科室（最大选择" + departments.size() + "）：");
    82.             int command1 = sc.nextInt();
    83.             if (existDepartment(command1) == false) {
    84.                 //不存在该科室
    85.                 continue;
    86.             }
    87.             //存在该科室
    88.             Department department = departments.get(command1 - 1);
    89.             //判断该科室是否存在医生
    90.             if (department.getDoctors().size() == 0) {
    91.                 //没有医生
    92.                 System.out.println("该科室无医生");
    93.                 return;
    94.             }
    95.             //有医生
    96.             while (true) {
    97.                 //显示该科室的全部医生
    98.                 showAllDoctor(department);
    99.                 Appointment a = new Appointment();
    100.                 a.setDepartmentName(department.getName());  //保存挂号科室名称
    101.  
    102.                 //选择看诊的医生
    103.                 ArrayList doctors = department.getDoctors();
    104.                 System.out.println("请选择看诊医生的序号（最大选择"+doctors.size()+"）：");
    105.                 int command2 = sc.nextInt();
    106.                 if(existDoctor(doctors,command2)==false){
    107.                     //不存在该医生
    108.                     continue;
    109.                 }
    110.                 //存在该医生
    111.                 Doctor d = doctors.get(command2-1);  //保存选择的医生对象
    112.                 //展示该医生的排班信息
    113.                 print(d);
    114.                 ArrayList arr = d.getSchedules();  //arr保存该医生的排班信息
    115.                 //如果该医生一次都没排过（arr数组都是空的）
    116.                 if(arr.size() == 0){
    117.                     System.out.println("该医生未排班，请重新选择");
    118.                     continue;
    119.                 }
    120.                 OUT:
    121.                 while (true) {
    122.                     //该医生排过班（arr数组不是空的）
    123.                     System.out.println("请选择看诊日期：");
    124.                     String dayStr = sc.next();
    125.                     LocalDate ld = LocalDate.parse(dayStr);
    126.                     for (int i = 0; i < arr.size(); i++) {
    127.                         Schedule s = arr.get(i);
    128.                         if(s.getToday().equals(ld)){
    129.                             //存在该天的排班情况
    130.                             if(s.isUpdate() == false){
    131.                                 System.out.println("该医生未排班，请重新选择日期");
    132.                                 continue OUT;
    133.                             }
    134.                             //当天排班了s.isUpdate() == true
    135.                             while (true) {
    136.                                 System.out.println("请输入看诊的时间（1：上午or2：下午）：");
    137.                                 int com = sc.nextInt();
    138.                                 if(com == 1) {  //选择上午看诊
    139.                                     if (s.isMorning() == false) {  //上午休息
    140.                                         System.out.println("该医生上午休息，请重新选择");
    141.                                         continue OUT;
    142.                                     } else {  //上午不休息
    143.                                         if (s.getmAppointNum() < s.getmTotalNum()) { //上午预约人数没满
    144.                                             s.setmAppointNum(s.getmAppointNum()+1);  //医生可预约人数-1
    145.  
    146.                                             a.setDoctorId(d.getDoctorId());  //设置看诊医生id
    147.                                             LocalDate appointDate = s.getToday();
    148.                                             LocalTime appointTime = s.getmStart();
    149.                                             LocalDateTime appointDateTime = LocalDateTime.of(appointDate,appointTime);
    150.                                             a.setAppointDateTime(appointDateTime);
    151.  
    152.                                             System.out.println("请输入患者姓名：");
    153.                                             a.setUserName(sc.next());
    154.                                             System.out.println("请输入患者性别：");
    155.                                             a.setSex(sc.next());
    156.                                             System.out.println("请输入患者年龄：");
    157.                                             a.setAge(sc.nextInt());
    158.                                             System.out.println("请输入患者电话：");
    159.                                             a.setTel(sc.next());
    160.                                             System.out.println("请输入病情描述：");
    161.                                             a.setDesc(sc.next());
    162.                                             System.out.println("预约成功");
    163.                                             return;
    164.                                         } else {
    165.                                             System.out.println("该医生当天上午已约满，请重新选择");
    166.                                             continue OUT;
    167.                                         }
    168.                                     }
    169.                                 }else if(com == 2){  // //选择下午看诊
    170.                                     if (s.isAfternoon() == false) {  //下午休息
    171.                                         System.out.println("该医生下午休息，请重新选择");
    172.                                         continue OUT;
    173.                                     } else {  //下午不休息
    174.                                         if (s.getaAppointNum() < s.getaTotalNum()) { //下午预约人数没满
    175.                                             s.setaAppointNum(s.getaAppointNum()+1);  //医生可预约人数-1
    176.  
    177.                                             a.setDoctorId(d.getDoctorId());  //设置看诊医生id
    178.                                             LocalDate appointDate = s.getToday();
    179.                                             LocalTime appointTime = s.getaStart();
    180.                                             LocalDateTime appointDateTime = LocalDateTime.of(appointDate,appointTime);
    181.                                             a.setAppointDateTime(appointDateTime);
    182.  
    183.                                             System.out.println("请输入患者姓名：");
    184.                                             a.setUserName(sc.next());
    185.                                             System.out.println("请输入患者性别：");
    186.                                             a.setSex(sc.next());
    187.                                             System.out.println("请输入患者年龄：");
    188.                                             a.setAge(sc.nextInt());
    189.                                             System.out.println("请输入患者电话：");
    190.                                             a.setTel(sc.next());
    191.                                             System.out.println("请输入病情描述：");
    192.                                             a.setDesc(sc.next());
    193.                                             System.out.println("预约成功");
    194.                                             return;
    195.                                         } else {
    196.                                             System.out.println("该医生当天下午已约满，请重新选择");
    197.                                             continue OUT;
    198.                                         }
    199.                                     }
    200.                                 }else{
    201.                                     System.out.println("输入有误，请重新输入");
    202.                                     continue;
    203.                                 }
    204.                             }
    205.  
    206.                         }
    207.                     }
    208.                     //不存在该天的排班情况
    209.                     System.out.println("您选择的看诊日期不在近7天，请重新选择");
    210.                     continue;
    211.                 }
    212.             }
    213.         }
    214.     }
    215.  
    216.     //查看某医生近7天的全部坐诊情况和预约情况（根据id查更加规范）
    217.     private void searchOneJob() {
    218.         //判断有没有科室（没有科室就一定没有医生）
    219.         if(isDepartment()==false) {
    220.             System.out.println("没有科室就没有医生");
    221.             return;
    222.         }
    223.  
    224.         //有科室
    225.         System.out.println("请输入你要查找的医生姓名：");
    226.         String name = sc.next();
    227.  
    228.         for (int i = 0; i < departments.size(); i++) {
    229.             Department department = departments.get(i);   //department保存第i个科室信息
    230.             ArrayList arr = department.getDoctors();  //创建arr集合（该集合保存的是某科室全部的医生信息）
    231.             if(arr.size() != 0){  //某科室有医生
    232.                 for (int j = 0; j < arr.size(); j++) {
    233.                     Doctor d = arr.get(j);  //保存医生信息
    234.                     if(d.getName().equals(name)){  //如果找到同名医生就输出
    235.                         System.out.println((d.getDepartmentName()));
    236.                         print(d);
    237.                         return;
    238.                     }
    239.                 }
    240.             }
    241.         }
    242.  
    243.         //遍历后还没找到
    244.         System.out.println("查无此人");
    245.     }
    246.  
    247.     //打印某医生的排班信息
    248.     private void print(Doctor d) {
    249.         System.out.println(d.getName()+"的排班情况：");
    250.  
    251.         ArrayList arr_s = d.getSchedules();  //医生的排班表
    252.         //先更新当前和未来6天的时间
    253.         updateSchedule(arr_s);
    254.  
    255.         if (arr_s.size() == 0){
    256.             //没有进行过一次排班（arr_s就是空的）
    257.             System.out.println("该医生未排班");
    258.             return;
    259.         }
    260.         //不是空的
    261.         for (int k = 0; k < arr_s.size() ; k++) {
    262.             Schedule s = arr_s.get(k);
    263.             System.out.println(s.getToday()+"的排班情况:");
    264.             if(s.isUpdate() == false){
    265.                 System.out.println("未排班");
    266.                 continue;
    267.             }
    268.             //已排班
    269.             if(s.isMorning() == true){
    270.                 System.out.println("上午："+s.getmStart()+"-"+s.getmEnd()+"  可预约人数："+s.getmTotalNum()+"  已预约人数："+s.getmAppointNum());
    271.             }else{
    272.                 System.out.println("上午休息");
    273.             }
    274.  
    275.             if(s.isAfternoon() == true){
    276.                 System.out.println("下午："+s.getaStart()+"-"+s.getaEnd()+"  可预约人数："+s.getaTotalNum()+"  已预约人数："+s.getaAppointNum());
    277.             }else{
    278.                 System.out.println("下午休息");
    279.             }
    280.         }
    281.     }
    282.  
    283.     private void searchAllJob() {
    284.         System.out.println("====全部医生的坐班信息====");
    285.         //判断有没有科室（没有科室就一定没有医生）
    286.         if(isDepartment()==false) {
    287.             System.out.println("没有科室就没有医生");
    288.             return;
    289.         }
    290.         //有科室
    291.         for (int i = 0; i < departments.size(); i++) {
    292.             Department department = departments.get(i);   //department保存第i个科室信息
    293.             ArrayList arr = department.getDoctors();  //创建arr集合（该集合保存的是某科室全部的医生信息）
    294.             if(arr.size() == 0){  //没有医生
    295.                 System.out.println("===="+department.getName()+"没有医生====");
    296.                 continue;
    297.             }
    298.             //有医生
    299.             System.out.println("===="+department.getName()+"医生的排班情况====");
    300.             for (int j = 0; j < arr.size(); j++) {
    301.                 Doctor d = arr.get(j);  //科室中第j个医生的信息
    302.                 print(d);  //打印医生的排班信息
    303.             }
    304.         }
    305.  
    306.     }
    307.  
    308.     private void setDoctorJob() {
    309.         System.out.println("====医生坐诊设置====");
    310.         //判断有没有科室
    311.         if(isDepartment()==false) {
    312.             return;
    313.         }
    314.         //有科室
    315.         while(true) {
    316.             showAllDepartment();  //展示已有科室
    317.             //先选择科室
    318.             System.out.println("请选择要排班的医生的科室（最大选择"+departments.size()+"）：");
    319.             int command1 = sc.nextInt();
    320.             if(existDepartment(command1)==false){
    321.                 //不存在该科室
    322.                 continue;
    323.             }
    324.             //存在该科室
    325.             Department department = departments.get(command1-1);
    326.             //判断该科室是否存在医生
    327.             if(department.getDoctors().size() == 0){
    328.                 //没有医生
    329.                 System.out.println("该科室无医生");
    330.                 continue;
    331.             }
    332.             //有医生
    333.             while(true){
    334.                 //显示该科室的全部医生
    335.                 showAllDoctor(department);
    336.  
    337.                 //选择需要排班的医生
    338.                 ArrayList doctors = department.getDoctors();
    339.                 System.out.println("请选择要排班的医生的序号（最大选择"+doctors.size()+"）：");
    340.                 int command2 = sc.nextInt();
    341.                 if(existDoctor(doctors,command2)==false){
    342.                     //不存在该医生
    343.                     continue;
    344.                 }
    345.                 //存在该医生
    346.                 Doctor d = doctors.get(command2-1);  //保存选择的医生对象
    347.  
    348.             // 为该医生设置坐诊时间
    349.  
    350.                 //获取该医生的坐诊情况
    351.                 ArrayList schedules = d.getSchedules();   //第一次getSchedules()里面肯定是空的
    352.                 //先更新当前和未来6天的时间
    353.                 updateSchedule(schedules);
    354.  
    355.                 //再给该医生当天和未来6天进行排班
    356.                 for (int i = 0; i < schedules.size(); i++) {
    357.                     Schedule s = schedules.get(i);
    358.                     updateDoctorSchedule(s);
    359.                 }
    360.                 System.out.println("已完成"+d.getName()+"排班"); //已某医生的排班
    361.                 return;
    362.             }
    363.         }
    364.     }
    365.  
    366.     //给医生进行排班
    367.     private void updateDoctorSchedule(Schedule s) {
    368.         LocalDate today = s.getToday();
    369.         System.out.println(today+"的安排如下：");
    370.         if(s.isUpdate()==false){  //未排班
    371.             System.out.println("未排班");
    372.         }else{  //已排班（显示排班情况）
    373.             //上午是否休息
    374.             if(s.isMorning() == false){
    375.                 //上午休息
    376.                 System.out.println("上午休息");
    377.             }else{
    378.                 //上午不休息
    379.                 System.out.println("上午："+s.getmStart()+"-"+s.getmEnd()+"  可预约人数："+s.getmTotalNum()+"  已预约人数："+s.getmAppointNum());
    380.             }
    381.  
    382.             //下午是否休息
    383.             if(s.isAfternoon() == false){
    384.                 //下午休息
    385.                 System.out.println("下午休息");
    386.             }else{
    387.                 //下午不休息
    388.                 System.out.println("下午："+s.getaStart()+"-"+s.getaEnd()+"  可预约人数："+s.getaTotalNum()+"  已预约人数："+s.getaAppointNum());
    389.             }
    390.         }
    391.         OUT:
    392.         while (true) {  //快捷键Ctrl+Alt+T
    393.             System.out.println("是否修改排班？y/n");
    394.             String command = sc.next();
    395.             switch(command){
    396.                 case "y":  //修改排班
    397.                     s.setUpdate(true);
    398.                     while (true) {
    399.                         System.out.println("上午是否看诊？y/n");
    400.                         String choose = sc.next();
    401.                         if(choose.equals("y")){
    402.                             s.setMorning(true);
    403.                             System.out.println("请输入看诊开始时间：");
    404.                             String start = sc.next();
    405.                             System.out.println("请输入看诊结束时间：");
    406.                             String end = sc.next();
    407.                             LocalTime ltstart = LocalTime.parse(start);
    408.                             LocalTime ltend = LocalTime.parse(end);
    409.                             s.setmStart(ltstart);  //保存开始时间
    410.                             s.setmEnd(ltend);  //保存结束时间
    411.                             System.out.println("请输入上午可预约人数：");
    412.                             int num = sc.nextInt();
    413.                             s.setmTotalNum(num);
    414.                             System.out.println("已完成设置上午排班信息");
    415.                             break;
    416.                         }else if(choose.equals("n")){
    417.                             s.setMorning(false);
    418.                             System.out.println("已设置上午休息");
    419.                             break;
    420.                         }else{
    421.                             System.out.println("没有该选择，请重新选择");
    422.                             continue;
    423.                         }
    424.                     }
    425.  
    426.                     while (true) {
    427.                         System.out.println("下午是否看诊？y/n");
    428.                         String choose = sc.next();
    429.                         if(choose.equals("y")){
    430.                             s.setAfternoon(true);
    431.                             System.out.println("请输入看诊开始时间：");
    432.                             String start = sc.next();
    433.                             System.out.println("请输入看诊结束时间：");
    434.                             String end = sc.next();
    435.                             LocalTime ltstart = LocalTime.parse(start);
    436.                             LocalTime ltend = LocalTime.parse(end);
    437.                             s.setaStart(ltstart);  //保存开始时间
    438.                             s.setaEnd(ltend);  //保存结束时间
    439.                             System.out.println("请输入下午可预约人数：");
    440.                             int num = sc.nextInt();
    441.                             s.setaTotalNum(num);
    442.                             System.out.println("已完成设置下午排班信息");
    443.                             break;
    444.                         }else if(choose.equals("n")){
    445.                             s.setAfternoon(false);
    446.                             System.out.println("已设置下午休息");
    447.                             break;
    448.                         }else{
    449.                             System.out.println("没有该选择，请重新选择");
    450.                             continue;
    451.                         }
    452.                     }
    453.                     return;
    454.                 case "n":  //不修改排班
    455.                     return;
    456.                 default:
    457.                     System.out.println("没有该选择，请重新选择");
    458.                     continue OUT;
    459.             }
    460.         }
    461.     }
    462.  
    463.     //更新当前和未来6天的时间
    464.     private void updateSchedule(ArrayList schedules) {
    465.         LocalDate now = LocalDate.now();  //获取当天日期（年月日）
    466.  
    467.         //存在两种情况
    468.         //schedules集合里面没有任何schedule（没有任何时间），就是第一次排班
    469.         //schedules集合存在7天的时间（可能部分是过期的，需要更新到今天的情况），非第一次排班  比如：3月1号更新过1-7号的，现在是3号，进去查看的时候应该更新为3-10号的
    470.  
    471.         //schedules集合里面没有任何schedule（没有任何时间）
    472.         if(schedules.size() == 0){   //第一次排班
    473.             for (int i = 0; i < 7; i++) {  //排7天
    474.                 Schedule s = new Schedule();  //创建一个Schedule对象
    475.                 s.setToday(now.plusDays(i));  //设置Schedule对象的日期（规则：第一天就是当天+0  第二天就是当天+1 ……）
    476.                 schedules.add(s); //把Schedule对象存到schedules集合中
    477.             }
    478.             return;
    479.         }
    480.  
    481.         //schedules集合存在7天的时间（可能部分是过期的，需要更新到今天的情况），非第一次排班  比如：3月1号更新过1-7号的，现在是3号，进去查看的时候应该更新为3-10号的
    482.         //非第一次排班，去除过期的时间
    483.         int count = 0;  //记入过期了几天（也就是删除了几天）
    484.         //集合中的删除操作，如果从前往后遍历，会存在漏删的情况，因此选择从后往前
    485.         for (int i = schedules.size()-1; i >= 0; i--) {  //遍历已保存的7天
    486.             LocalDate ld = schedules.get(i).getToday();   //已经保存的第i个日期
    487.             if(ld.isBefore(now)){  //保存的第i个日期早于今天的日期
    488.                 schedules.remove(i);
    489.                 count++;
    490.             }
    491.         }
    492.  
    493.         //如果有删除过期的时间，那么需要补全7天
    494.         //count == 0说明没有删除日期
    495.         if(count == 0){
    496.             return;
    497.         }
    498.         //count不等于0说明有删除(那么应该从count-1开始补全日期，比如删除了5天，剩下2天，那么就应该从第3个位置（索引2）开始补5天)
    499.         for (int i=7-count; i < 7; i++) {
    500.             Schedule s = new Schedule();  //创建一个Schedule对象
    501.             s.setToday(now.plusDays(i));
    502.             schedules.add(s);
    503.         }
    504.     }
    505.  
    506.     private void addDoctor() {
    507.         System.out.println("====添加医生====");
    508.         //判断有没有科室
    509.         if(isDepartment()==false) {
    510.             return;
    511.         }
    512.         //有科室
    513.         Doctor d = new Doctor();
    514.         while(true){
    515.             showAllDepartment();  //展示已有科室
    516.             //先选择科室
    517.             System.out.println("请选择新医生的入职科室（最大选择"+departments.size()+"）：");
    518.             int command = sc.nextInt();
    519.             if(existDepartment(command)==false){
    520.                 //不存在该科室
    521.                 continue;
    522.             }
    523.             //存在该科室
    524.             Department department = departments.get(command-1);  //department记录选择的科室
    525.             d.setDepartmentName(department.getName()); //记录员工科室
    526.  
    527.             //录入医生id
    528.             d.setDoctorId(UUID.randomUUID().toString());   //随机返回16位的id
    529.  
    530.             System.out.println("请输入医生姓名：");
    531.             d.setName(sc.next());
    532.  
    533.             System.out.println("请输入医生性别：");
    534.             d.setGender(sc.next());
    535.  
    536.             System.out.println("请输入医生年龄：");
    537.             d.setAge(sc.nextInt());
    538.  
    539.             System.out.println("请输入医生主治方向：");
    540.             d.setSpecialty(sc.next());
    541.  
    542.             System.out.println("请输入医生入职时间（格式：yyyy-MM-dd）：");
    543.             String joinDateString = sc.next();
    544.             d.setJoinDate(LocalDate.parse(joinDateString));   //把字符串转换成LocalDate对象
    545.  
    546.             //添加完医生个人信息，还需要把医生加到所在部门的集合里
    547.             department.getDoctors().add(d);
    548.             System.out.println("添加医生成功");
    549.             break;
    550.         }
    551.     }
    552.  
    553.     private void modifyDepartment() {
    554.         System.out.println("====修改科室名称====");
    555.         //判断有没有科室
    556.         if(isDepartment()==false){
    557.             return;
    558.         }
    559.         //有科室
    560.         while(true) {
    561.             showAllDepartment();
    562.             System.out.println("请选择你要修改的科室序号（最大选择"+departments.size()+"）：");
    563.             int command = sc.nextInt();
    564.             if(existDepartment(command)==false){
    565.                 //不存在该科室
    566.                 continue;
    567.             }
    568.             //存在该科室
    569.             Department department = departments.get(command-1);  //department记录选择的科室
    570.             System.out.println("你要为科室修改的新名字是：");
    571.             String newName = sc.next();
    572.             department.setName(newName);
    573.             System.out.println("修改成功！");
    574.             break;
    575.         }
    576.     }
    577.     
    578.     private void deleteDepartment() {
    579.         System.out.println("====添加科室====");
    580.         //判断有没有科室
    581.         if(isDepartment()==false){
    582.             return;
    583.         }
    584.         //有科室
    585.         while(true){
    586.             showAllDepartment();
    587.             System.out.println("请选择你要删除的科室序号（最大选择"+departments.size()+"）：");
    588.             int command = sc.nextInt();
    589.             if(existDepartment(command)==false){
    590.                 //不存在该科室
    591.                 continue;
    592.             }
    593.             //存在该科室
    594.             Department department = departments.get(command-1);
    595.             if(department.getDoctors().size() != 0){
    596.                 //科室中存在医生
    597.                 System.out.println("科室中存在医生，不能删除科室");
    598.                 return;
    599.             }
    600.             //科室中无医生，可以删除
    601.             departments.remove(command-1);
    602.             System.out.println("删除科室成功");
    603.             break;
    604.         }
    605.     }
    606.  
    607.     //添加科室
    608.     private void addDepartment() {
    609.         System.out.println("====添加科室====");
    610.         OUT:  //标签
    611.         while(true){
    612.             System.out.println("请输入添加的科室名称：");
    613.             String name = sc.next();
    614.             //判断科室是否存在
    615.             for (int i = 0; i < departments.size(); i++) {
    616.                 if (departments.get(i).getName().equals(name) == true) {
    617.                     //科室已存在
    618.                     System.out.println("您创建的科室已存在，请重新输入");
    619.                     continue OUT;  //继续执行下一次外面的死循环（OUT）
    620.                 }
    621.             }
    622.             Department d = new Department();
    623.             d.setName(name);
    624.             departments.add(d);
    625.             System.out.println("创建科室成功");
    626.             break;
    627.         }
    628.     }
    629.  
    630.     //展示一个科室的全部医生
    631.     private void showAllDoctor(Department department){
    632.         System.out.println("===="+department.getName()+"====");
    633.         ArrayList arr = department.getDoctors();
    634.         for (int i = 0; i < arr.size(); i++) {
    635.             System.out.println(i+1 +"." + arr.get(i).getName());
    636.         }
    637.     }
    638.  
    639.     //展示已有的每个科室
    640.     private void showAllDepartment(){
    641.         System.out.println("====已有科室====");
    642.         for (int i = 0; i < departments.size(); i++) {
    643.             System.out.println(i+1+"."+departments.get(i).getName());
    644.         }
    645.     }
    646.  
    647.     //判断有没有科室
    648.     private boolean isDepartment(){
    649.         if(departments.size()==0){
    650.             //没有科室
    651.             System.out.println("当前无科室，请先添加科室");
    652.             return false;
    653.         }
    654.         return true;
    655.     }
    656.  
    657.     //判断选择的序号是否有科室存在
    658.     private boolean existDepartment(int command){
    659.         if(command < 1 || command > departments.size()){
    660.             //没有该科室
    661.             System.out.println("不存在该科室，请重新选择");
    662.             return false;
    663.         }
    664.         //有该科室
    665.         return true;
    666.     }
    667.  
    668.     //判断选择的序号是否有医生存在
    669.     private boolean existDoctor(ArrayList doctors,int command){
    670.         if(command < 1 || command > doctors.size()){
    671.             //没有该医生
    672.             System.out.println("不存在该医生，请重新选择");
    673.             return false;
    674.         }
    675.         //有该医生
    676.         return true;
    677.     }
    678. }
  • 相关阅读:
    springsecurity框架笔记
    读书笔记：《指标陷阱》
    echarts：graph图表拖拽节点
    C#：EXCEL列名、列序号之间互相转换
    51单片机学习笔记5 流水灯实现及蜂鸣器控制
    查看视频文件关键帧间隔
    Rust开发——切片（slice）类型
    腾讯云 AI 绘画：文生图、图生图、图审图 快速入门
    淘女郎买家秀API接口
    Linux之自动化运维工具ansible详解
  • 原文地址：https://blog.csdn.net/qq_50755868/article/details/136437102