✍版权声明：@CSDN遊光
版权声明：
@Kcx@遊光@胤殁@Karl@Karlcixio
有幸您能来看我的博客，本博客仅供大家学术交流，如您有需要将本博客用作它用，请与我联系！
我的联系方式：
微信搜索公众号：Karlcixio
也可以直接扫描以下二维码：
----------------------------------
个人 QQ：1005589159
?第零步：审题！！！
首先，我们先来看看题目要求，然后再罗列我们大体需要做些什么：
- 创建实体类Student，并写入相关变量及方法；
- 创建实体类Course（采用自接口比较），并写入相关变量及方法；
（也可创建外部接口比较器CourseComparator类，写入其比较规则；） - 创建测试类SimluCourse，并写入测试过程；
- 在测试类中，进行相关数据测试；
ps：注意右框右下角的要求 —— 操作过程中，若输入的数据非法，做相应的提示，如选修不存在的课程。
?第一步：实体类Student
package 【PackageName】;
public class Student {
private String sid;
private String sname;
private TreeSet<Course> scourses;
public Student() {
}
public Student(String sid, String sname, TreeSet<Course> scourse) {
this.sid = sid;
this.sname = sname;
this.scourses = scourse;
}
public String getSid() {
return sid;
}
public void setSid(String sid) {
this.sid = sid;
}
public String getSname() {
return sname;
}
public void setSname(String sname) {
this.sname = sname;
}
public TreeSet<Course> getScourses() {
return scourses;
}
public void setScourses(TreeSet scourses) {
this.scourses = scourses;
}
}
?第二步：实体类Course
- 方法1：实体类Course（自接口比较）
package 【PackageName】;
import java.util.Comparator;
import java.util.Objects;
public class Course implements Comparable<Course>{
private String cid;
private String cname;
public Course(){}
public Course(String cid, String cname) {
this.cid = cid;
this.cname = cname;
}
public Course(String cid) {
this.cid = cid;
}
public String getCid() {
return cid;
}
public void setCid(String cid) {
this.cid = cid;
}
public String getCname() {
return cname;
}
public void setCname(String cname) {
this.cname = cname;
}
@Override
public String toString() {
return "\n\t* 编号：" + cid+", 科目名：【" + cname+"】\n";
}
//@Kcx: _compare type String
@Override
public int compareTo(Course o) {
return this.getCid().compareTo(o.getCid());
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Course course = (Course) o;
return Objects.equals(cid, course.cid) &&
Objects.equals(cname, course.cname);
}
@Override
public int hashCode() {
return Objects.hash(cid, cname);
}
}
- 方法2：实体类Course（无自接口比较）& 比较器Coursecomparator类（外部接口比较）
- - 实体类Course：
package 【PackageName】;
import java.util.Comparator;
import java.util.Objects;
public class Course /*//@Kcx _此句注释代码为【第二步】方法1的自接口比较的代码：implements Comparable<Course>*/ {
private String cid;
private String cname;
public Course(){}
public Course(String cid, String cname) {
this.cid = cid;
this.cname = cname;
}
public Course(String cid) {
this.cid = cid;
}
public String getCid() {
return cid;
}
public void setCid(String cid) {
this.cid = cid;
}
public String getCname() {
return cname;
}
public void setCname(String cname) {
this.cname = cname;
}
@Override
public String toString() {
return "\n\t* 编号：" + cid+", 科目名：【" + cname+"】\n";
}
//@Kcx: _以下注释代码为【第二步】方法1的自接口比较的代码；
/*
//@Kcx: _compare type String
@Override
public int compareTo(Course o) {
return this.getCid().compareTo(o.getCid());
}
*/
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Course course = (Course) o;
return Objects.equals(cid, course.cid) &&
Objects.equals(cname, course.cname);
}
@Override
public int hashCode() {
return Objects.hash(cid, cname);
}
}
- - 比较器Coursecomparator类：
package 【PackageName】;
import java.util.Comparator;
public class CourseComparator implements Comparator<Course> {
@Override
//@Kcx: _外部接口比较器（Course型），对String型变量即Course类的成员变量id进行比较排序；
// 注：compareTo的返回值为整型；
// ps:可以用自接口比较~见Course方法内；
//@Kcx: _use out-comparator to compare type String
public int compare(Course o1, Course o2) {
return o1.getCid().compareTo(o2.getCid());
}
}
?第三步：测试类SimluCourse
package com.Task;
import java.util.*;
/**
* *****************
* K-cx
* com.Task
* 2019/3/30 10:20
* *****************
*/
/**
*----------------------------------------------------------------------------------------
*@Aunthor:K-cx
* Tip：
* courses —— Course型【数组】，用于存放【全部】科目。（该数组仅做原始参考作用不参与任何变化）
* -->主要依据其下标的初始不变性协助处理其他容器及数组
* coursesS —— TreeSet型【容器】（内仅存放Course型对象），用于存放用户【选择】科目【后】的课程情况。
* -->在该容器内做科目选择后，实时处理选后的科目变化
*
* selCourse —— Course型【数组】，用于存放用户【所选】的课程。
* -->该数组仅用于选课过程中，选课结束，全元赋给courseEnd，做后续的删改工作
* courseEnd —— TreeSet型【容器】（内仅存放Course型对象），用于存放用户【最终确定】的课程。
* -->该容器用于后续的删改已选课程，初始元素由selCourse进行赋给，
* 后续利用其容器特性进行删改工作
*----------------------------------------------------------------------------------------
*/
public class SimluCourse {
public static void main(String[] args) {
System.out.println("* 学生选课模拟系统");
/**
*----------------------------------------------------------------------------------------
*@Aunthor:K-cx
*@Time:2019/3/31_14:06
*@Description:
* _创建Course型数组courses，放入9门课程；
*----------------------------------------------------------------------------------------
*/
Course[] courses=new Course[9];
courses[0]=new Course("001","语文");
courses[1]=new Course("002","数学");
courses[2]= new Course("003","英语");
courses[3]=new Course("004","物理");
courses[4]=new Course("005","化学");
courses[5]=new Course("006","生物");
courses[6]=new Course("007","历史");
courses[7]=new Course("008","政治");
courses[8]=new Course("009","地理");
/**
*----------------------------------------------------------------------------------------
*@Aunthor:K-cx
*@Time:2019/3/31_14:08
*@Description:
* _创建TreeSet样Course型容器对象coursesS， （包含所有的课程）
* 并使用外部比较器CourseComparator用于对容器内所有Course型对象进行比较排序；
*----------------------------------------------------------------------------------------
*/
TreeSet<Course> coursesS=new TreeSet<>(new CourseComparator());
/**
*----------------------------------------------------------------------------------------
*@Aunthor:K-cx
*@Time:2019/3/31_14:09
*@Description:
* _将数组courses中所有Course型对象全部放入TreeSet样Course型容器对象coursesS内；
*----------------------------------------------------------------------------------------
*/
for(int i=0;i<courses.length;i++){
coursesS.add(courses[i]);
}
/**
*----------------------------------------------------------------------------------------
*@Aunthor:K-cx
*@Time:2019/3/31_14:11
*@Description:
* _输出提示信息，并将学生信息（姓名、学号）进行记录；
* 创建Student型对象student，将初始化信息放入构造；
*----------------------------------------------------------------------------------------
*/
System.out.println("---------------------------------------------------------\n" +
"* 本次选课提供[科目]有：\n* "
+coursesS);
Scanner sin=new Scanner(System.in);
System.out.println("---------------------------------------------------------\n" +
"* 请输入你的[学号]：");
String sid=sin.next();
System.out.println("* 请输入你的[姓名]：");
String sname=sin.next();
Student student=new Student(sid,sname,coursesS);
/**
*----------------------------------------------------------------------------------------
*@Aunthor:K-cx
*@Time:2019/3/31_14:13
*@Description:
* _定义计数器count（数组selCourse的下标），用于对数组selCourse内元素进行依次放入处理；
* 创建Course型数组selCourse用于对用户所选的课程进行收录；
*----------------------------------------------------------------------------------------
*/
int count=0;
Course[] selCourse=new Course[9];
/**
*----------------------------------------------------------------------------------------
*@Aunthor:K-cx
*@Time:2019/3/31_14:16
*@Description:
* _立外部循环标号：fChoseCourse，便于选课3门后（或多于3门后）跳出循环体；
*----------------------------------------------------------------------------------------
*/
fChoseCourse:while (true){
//@Kcx: _小于三门（已选1、2门课）时，进行以下语句；
if (count<3){
//@Kcx: _输出提示信息；
System.out.println("---------------------------------------------------------\n" +
"* 你可选的[科目]有：\n" +
"* "+coursesS);
System.out.println("* 请输入你的第"+(count+1)+"门[课程]对应[编号]：");
//@Kcx: _记录String类型的编号（与Course类的成员变量cid相同）；
String selCourseNum=sin.next();
//@Kcx: _将Sting型转换为int型，便于使用数组（courses）的下标，
// 从而直接获得对应编号的科目名；
int selCourseNumInt=Integer.parseInt(selCourseNum);
//@Kcx: _原始想法；
//@Kcx: _original idea
/*System.out.println("请输入你的第"+(count+1)+"门科目对应名称：");
String selCourseName=sin.next();*/
//@Kcx: _越界提示信息，并重新进入外部循环；
//@Kcx: _越界判定解释：共9门课，数组下标最大值为8，
// 若输入（selCourseNumInt）的值-1【非】小于等于8，即输入的值【非】小于等于9，
// 输出错误提示信息，重新进入外部循环；
if (selCourseNumInt-1>8){
System.out.println("* 输入有误！请重新输入！");
continue fChoseCourse;
}
//@Kcx: _创建Course型数组selCourse中selCourse[count]元素的Course型对象，并传参构造；
// 注：Course对象两个参数类型都为String，参数一：编号，参数二：编号对应的课程名称；
// 例：编号001的课程，由于其courses数组对应下标要-1，
// 因此下标为0，再.它的【获取名称】方法，获取课程名称；
selCourse[count]=new Course(selCourseNum,courses[selCourseNumInt-1].getCname());
//@Kcx: _判断在Course型容器coursesS中是否包含——刚刚所创建的Course型对象selCourse[count]；
if (coursesS.contains(selCourse[count])) {
//@Kcx: _若包含，则拿走容器coursesS中与selCourse[count]相同的Course型对象；
coursesS.remove(selCourse[count]);
//@Kcx: _selCourse数组下标+1；
count++;
}else {
//@Kcx: _若不包含，输出错误提示信息，结束本次循环，进入下一次循环
// （由于count的条件限制，无需continue）；
System.out.println("* 该课不存在（输入[编号]有误），或已被选过！请重新选课！");
}
}
//@Kcx: _大于等于三门（即已选满三门课程）时，进行以下语句；
if (count>=3){
//@Kcx: _输出提示信息；
System.out.println("---------------------------------------------------------\n" +
"* 你可选的[科目]有：\n" +
"* "+coursesS);
//@Kcx: _立内部循环标号：fChoseCourseContinue，便于选3门课后继续选后续（4、5、6……）课程；
fChoseCourseContinue:while (true) {
//@Kcx: _输出提示信息；
System.out.println("* 已选" + count + "门[课程]，是否继续选课？\n" +
"* [是]请输入：1；\t[否]请输入：2");
//@Kcx: _记录是否继续进行选课的对应输入数字；
int isContinue = sin.nextInt();
//@Kcx: _若输入2：不进行继续选课，则跳出外部循环（break标号fChoseCourse）；
//@Kcx: _if 2 --> out ChoseCourse
if (isContinue == 2) {
break fChoseCourse;
}
//@Kcx: _若输入的不是1也不是2（注意else if的区间范围），则输出错误提示信息，
// 并重新进入内部循环（continue标号fChoseCourseContinue）；
//@Kcx: _if !(1||2) --> print error and continue ChoseCourseContinue
else if (isContinue != 1) {
System.out.println("* 输入有误！请重新输入！");
continue fChoseCourseContinue;
}
//@Kcx: _若输入1：继续选课，则跳出内部循环（continue标号fChoseCourseContinue）
// 继续执行if (count>=3)语句块中剩余代码，进行继续选课；
//@Kcx: _if 1 --> continue ChoseCourse
break fChoseCourseContinue;
}
//@Kcx: _以下为继续选课；
//@Kcx: _输出提示信息；
System.out.println("* 请输入你的第"+(count+1)+"门[课程]对应[编号]：");
//@Kcx: _记录String类型的编号（与Course类的成员变量cid相同）；
String selCourseNum=sin.next();
//@Kcx: _将Sting型转换为int型，便于使用数组（courses）的下标，
// 从而直接获得对应编号的科目名；
int selCourseNumInt=Integer.parseInt(selCourseNum);
//@Kcx: _原始想法；
//@Kcx: _original idea
/*System.out.println("请输入你的第"+(count+1)+"门科目对应名称：");
String selCourseName=sin.next();*/
//@Kcx: _越界提示信息，并重新进入外部循环；
//@Kcx: _越界判定解释：共9门课，数组下标最大值为8，
// 若输入（selCourseNumInt）的值-1【非】小于等于8，即输入的值【非】小于等于9，
// 输出错误提示信息，重新进入外部循环；
if (selCourseNumInt-1>8){
System.out.println("* 输入有误！请重新输入！");
continue fChoseCourse;
}
//@Kcx: _创建Course型数组selCourse中selCourse[count]元素的Course型对象，并传参构造；
// 注：Course对象两个参数类型都为String，参数一：编号，参数二：编号对应的课程名称；
// 例：编号001的课程，由于其courses数组对应下标要-1，
// 因此下标为0，再.它的【获取名称】方法，获取课程名称；
selCourse[count]=new Course(selCourseNum,courses[selCourseNumInt-1].getCname());
//@Kcx: _判断在Course型容器coursesS中是否包含——刚刚所创建的Course型对象selCourse[count]；
if (coursesS.contains(selCourse[count])) {
//@Kcx: _若包含，则拿走容器coursesS中与selCourse[count]相同的Course型对象；
coursesS.remove(selCourse[count]);
//@Kcx: _selCourse数组下标+1；
count++;
}else {
//@Kcx: _若不包含，输出错误提示信息，结束本次循环，进入下一次循环
// （由于count的条件限制，无需continue）；
System.out.println("* 该课不存在（输入[编号]有误），或已被选过！请重新选课！");
}
}
}
//@Kcx: _测试： 计数器count是否正确计数 & 用户选的课程是否收入正确；
//@Kcx: _Test count & selCourse
/*System.out.println(count);*/
/*for(Object element:selCourse){
System.out.print(element+" ");
}*/
/**
*----------------------------------------------------------------------------------------
*@Aunthor:K-cx
*@Time:2019/3/31_15:16
*@Description:
* _创建TreeSet样Course型容器对象courseEnd， （包含用户最终所选的课程）
* 并使用外部比较器CourseComparator用于对容器内所有Course型对象进行比较排序；
*----------------------------------------------------------------------------------------
*/
TreeSet<Course> courseEnd=new TreeSet<>(new CourseComparator());
/**
*----------------------------------------------------------------------------------------
*@Aunthor:K-cx
*@Time:2019/3/31_15:21
*@Description:
* _将存放用户所有选课的Course型数组selCourse中的所有元素全部放入容器对象courseEnd
* （便于使用add、remove等容器特有方法）；
*----------------------------------------------------------------------------------------
*/
for(int i=0;i<count;i++){
courseEnd.add(selCourse[i]);
}
//@Kcx: _输出显示信息；
System.out.println("---------------------------------------------------------\n" +
"* 学号为： ["+student.getSid()+"] ，名叫 ["+student.getSname()+"] 的同学");
/**
*----------------------------------------------------------------------------------------
*@Aunthor:K-cx
*@Time:2019/3/31_15:25
*@Description:
* _立标号fConfirmCourseContinue
* （立不立无所谓，不存在多层循环跳出问题，这里立是为了方便理解）；
*----------------------------------------------------------------------------------------
*/
fConfirmCourseContinue:while (true) {
//@Kcx: _输出提示信息；
System.out.println("---------------------------------------------------------\n" +
"* 你已选的[课程]有：\n" +
"* "+courseEnd+ "\n" +
"---------------------------------------------------------");
System.out.println("* 请确认你的选课。\n[确认]请输入：1；\t\t[删除]请输入：2；\t\t[修改]请输入：3；\n[查看已选课程]请输入：4；\t\t[查看可选科目]请输入：5；");
//@Kcx: _记录确认信息，或是需要（继续）进行删除或修改的对应输入数字；
int isConfirm = sin.nextInt();
//@Kcx: _若输入4：进行对已选课的查询；
//@Kcx: _if 4 --> check what has been chosen
if (isConfirm==4){
//@Kcx: _“ 直接 ”继续循环；
continue fConfirmCourseContinue;
}
//@Kcx: _若输入5：进行对可选科的查询；
//@Kcx: _if 5 --> check what can be chosen
if (isConfirm==5){
System.out.println("---------------------------------------------------------\n"+
"* 你可选的[科目]有：\n"+
"* "+coursesS);
//@Kcx: _继续循环（为了能执行输入1时的代码，采用continue）；
continue fConfirmCourseContinue;
}
//@Kcx: _若输入2：进行对已选课的【删除】；
//@Kcx: _if 2 --> delete chosen course
if (isConfirm == 2) {
//@Kcx: _输出提示信息；
System.out.println("* 请输入删除[课程]的[编号]：");
//@Kcx: _记录被【删除】的已选课科目String类型的编号（与Course类的成员变量cid相同）；
String whichNumNeed=sin.next();
//@Kcx: _将Sting型转换为int型，便于使用数组（courses）的下标，
// 从而对相应编号的科目进行一系列操作；
int whichNumNeedInt=Integer.parseInt(whichNumNeed);
//@Kcx: _测试： 下标是否已经正确转换为int类型；
//@Kcx: _Test subscript whether it has conversed to type int correctly
/*System.out.println(whichNumNeedInt);*/
//@Kcx: _创建Course型对象whichCourseNeed，并传参构造；
// 注：Course对象两个参数类型都为String，参数一：编号，参数二：编号对应的课程名称；
// 例：编号001的课程，由于其courses数组对应下标要-1，
// 因此下标为0，再.它的【获取名称】方法，获取课程名称；
Course whichCourseNeed=new Course(whichNumNeed,courses[whichNumNeedInt-1].getCname());
//@Kcx: _判断Course型容器对象courseEnd中是否包含——刚刚所创建的Course型对象whichCourseNeed；
if (!courseEnd.contains(whichCourseNeed)){
//@Kcx: _若不包含，则输出错误提示信息，并结束本次循环，进入下一次循环；
System.out.println("* 该需被删除课不存在（输入[编号]有误），请重新进入！");
continue fConfirmCourseContinue;
}
//@Kcx: _若包含，则拿走course型对象容器courseEnd中的与whichCourseNeed内容相同的元素，完成【删除】；
courseEnd.remove(whichCourseNeed);
//@Kcx: _除了以下代码（到EEE），其余代码和【修改】代码大体一致；
//@Kcx: _other code is the same as the below part(Change)by and large,just the below is different(to EEE)
if (courseEnd.size()<3){
//@Kcx: _若完成删除工作后，course型对象容器courseEnd的大小小于3，则输出错误提示信息，
// 并将已删除元素重新放入courseEnd容器，结束本次循环，进行下一次循环；
System.out.println("* 每名学生至少选择三门[课程]，无法操作！");
courseEnd.add(whichCourseNeed);
continue fConfirmCourseContinue;
}
//@Kcx: _若完成删除工作后，course型对象容器courseEnd的大小没有小于3，
// 那么，将被删除元素，重新放回course型对象容器coursesS中，
// 便于下一次【删除】和【修改】时，该元素重新进入选单；
coursesS.add(whichCourseNeed);
//@Kcx: _与【修改】的差异代码到此为止；
//@Kcx: _EEE
//@Kcx: _继续循环（为了能执行输入1时的代码，采用continue）；
continue fConfirmCourseContinue;
}
//@Kcx: _若输入3：进行对已选课的【修改】；
//@Kcx: _if 3 --> change chosen course
else if (isConfirm==3){
//@Kcx: _输出提示信息；
System.out.println("* 请输入被修改[课程]的[编号]：");
//@Kcx: _记录被【修改】的已选课科目String类型的编号（与Course类的成员变量cid相同）；
String whichNumNeed=sin.next();
//@Kcx: _将Sting型转换为int型，便于使用数组（courses）的下标，
// 从而对相应编号的科目进行一系列操作；
int whichNumNeedInt=Integer.parseInt(whichNumNeed);
//@Kcx: _测试： 下标是否已经正确转换为int类型；
//@Kcx: _Test subscript whether it has conversed to type int correctly
/*System.out.println(whichNumNeedInt);*/
//@Kcx: _创建Course型对象whichCourseNeed，并传参构造；
// 注：Course对象两个参数类型都为String，参数一：编号，参数二：编号对应的课程名称；
// 例：编号001的课程，由于其courses数组对应下标要-1，
// 因此下标为0，再.它的【获取名称】方法，获取课程名称；
Course whichCourseNeed=new Course(whichNumNeed,courses[whichNumNeedInt-1].getCname());
//@Kcx: _判断Course型容器对象courseEnd中是否包含——刚刚所创建的Course型对象whichCourseNeed；
if (!courseEnd.contains(whichCourseNeed)){
//@Kcx: _若不包含，则输出错误提示信息，并结束本次循环，进入下一次循环；
System.out.println("* 该需被修改课不存在（输入[编号]有误），请重新进入！");
continue fConfirmCourseContinue;
}
//@Kcx: _若包含，则拿走course型对象容器courseEnd中的与whichCourseNeed内容相同的元素，完成【移除】；
courseEnd.remove(whichCourseNeed);
//@Kcx: _除了以下代码（到EEE），其余代码和【删除】代码大体一致；
//@Kcx: _other code is the same as the above part(Delete)by and large,just the below is different(to EEE)
//@Kcx: _将已【移除】的元素重新放入Course型容器coursesS中，便于进行【修改】操作时，目前可选课程的正确性；
coursesS.add(whichCourseNeed);
//@Kcx: _输出提示信息；
System.out.println("* 剩余可选选课[科目]还有：\n" +
"* " + coursesS+
"\n* 请输入你新改[课程]的[编号]:");
//@Kcx: _记录想要【改为】的选课科目String类型的编号（与Course类的成员变量cid相同）；
String whichNumToChange=sin.next();
//@Kcx: _将Sting型转换为int型，便于使用数组（courses）的下标，
// 从而对相应编号的科目进行一系列操作；
int whichNumToChangeInt=Integer.parseInt(whichNumToChange);
//@Kcx: _创建Course型对象whichCourseToChange，并传参构造；
// 注：Course对象两个参数类型都为String，参数一：编号，参数二：编号对应的课程名称；
// 例：编号001的课程，由于其courses数组对应下标要-1，
// 因此下标为0，再.它的【获取名称】方法，获取课程名称；
Course whichCourseToChange=new Course(whichNumToChange,courses[whichNumToChangeInt-1].getCname());
//@Kcx: _判断Course型容器对象coursesS中是否包含——刚刚所创建的Course型对象whichCourseToChange；
if (!coursesS.contains(whichCourseToChange)){
//@Kcx: _若不包含，则输出错误提示信息，
// 将被【修改】元素放回Course型容器对象courseEnd中，
// 将已被重新放回coursesS的whichCourseNeed元素做【移除】工作，
// 并结束本次循环，进入下一次循环；
System.out.println("* 该需新改课不存在（输入[编号]有误），请重新进入！");
courseEnd.add(whichCourseNeed);
coursesS.remove(whichCourseNeed);
continue fConfirmCourseContinue;
}
//@Kcx: _若包含，则将想要【改为】的course型对象whichCourseToChange添入courseEnd对象容器中，
// 并拿走course型对象容器coursesS中的与whichCourseToChange内容相同的元素，完成【修改】；
courseEnd.add(whichCourseToChange);
coursesS.remove(whichCourseToChange);
//@Kcx: _与【删除】的差异代码到此为止；
//@Kcx: _EEE
//@Kcx: _继续循环（为了能执行输入1时的代码，采用continue）；
continue fConfirmCourseContinue;
}
//@Kcx: _若输入的既不是1：确认，也不是2：删除，又不是3：修改，
// 则输出错误提示信息，结束本次循环，重新进入循环；
//@Kcx: _if !(1||2||3) --> print error and continue fConfirmCourseContinue
else if (isConfirm != 1) {
System.out.println("* 输入有误！请重新输入！");
continue fConfirmCourseContinue;
}
//@Kcx: _若输入1：确认，则完成【学生选课】，输出学生信息及选课信息！结束程序。
//@Kcx: _if 1 --> confirm
System.out.println("---------------------------------------------------------\n" +
"* 学号为： ["+student.getSid()+"] ，名叫 ["+student.getSname()+"] 的同学\n" +
"---------------------------------------------------------\n" +
"* 你最终确认的[课程]如下：\n" +
"* "+courseEnd+ "\n" +
"---------------------------------------------------------");
System.exit(0);
}
}
}
?第四步：数据测试
1. 成功运行程序
2. 输入学生相关信息
3. 选择3门课程
由于题中要求最低选三门，此处以“009”、“006”、“003”为例（用户可以输入错误信息来测试程序的可执行性）
4. 根据提示信息继续选择第4、5门选课，并结束选课
为了测试后续的删除和修改选课程序，此处增入第4、5门选课，以“001”、“002”为例（用户可以输入错误信息来测试程序的可执行性）
选择继续选课：
选择第4、5门课：
结束选课：
5. 测试【删除】功能
测试程序的删除功能的可执行性，此处以删除“009”一门已选选课为例（用户可以输入错误信息来测试程序的可执行性）
选择删除选课：
输入被删除的课程编号，完成删除：
6. 测试【修改】功能
测试程序的修改功能的可执行性，此处以修改“006”一门已选选课为“004”为例（用户可以输入错误信息来测试程序的可执行性）
选择修改选课：
输入被修改的课程编号：
输入新改课程的编号，完成修改：
7. 测试【查询】功能
- 测试【查看已选课程】功能
- 测试【查看可选科目】功能
8. 【确认】学生选课信息
?End
版权声明：
@Kcx@遊光@胤殁@Karl@Karlcixio
感谢您能来看我的博客，本博客仅供大家学术交流，如您有需要将本博客用作它用，请与我联系！
我的联系方式：
微信搜索公众号：Karlcixio
也可以直接扫描以下二维码：
----------------------------------
个人 QQ：1005589159
655
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
