Blog_3_pta6-8次作业总结
某高校课程从性质上分为：必修课、选修课，从考核方式上分为：考试、考察。
考试的总成绩由平时成绩、期末成绩分别乘以权重值得出，比如平时成绩权重0.3，期末成绩权重0.7，总成绩=平时成绩*0.3+期末成绩*0.7。
考察的总成绩直接等于期末成绩
必修课的考核方式必须为考试，选修课可以选择考试、考察任一考核方式。
1、输入：
包括课程、课程成绩两类信息。
课程信息包括：课程名称、课程性质、考核方式（可选，如果性质是必修课，考核方式可以没有）三个数据项。
课程信息格式：课程名称+英文空格+课程性质+英文空格+考核方式
课程性质输入项：必修、选修
考核方式输入选项：考试、考察
课程成绩信息包括：学号、姓名、课程名称、平时成绩（可选）、期末成绩
课程信息格式：学号+英文空格+姓名+英文空格+课程名称+英文空格+平时成绩+英文空格+期末成绩
以上信息的相关约束：
1）平时成绩和期末成绩的权重默认为0.3、0.7
2）成绩是整数，不包含小数部分，成绩的取值范围是【0,100】
3）学号由8位数字组成
4）姓名不超过10个字符
5）课程名称不超过10个字符
6）不特别输入班级信息，班级号是学号的前6位。
2、输出：
输出包含三个部分，包括学生所有课程总成绩的平均分、单门课程成绩平均分、单门课程总成绩平均分、班级所有课程总成绩平均分。
为避免误差，平均分的计算方法为累加所有符合条件的单个成绩，最后除以总数。
1）学生课程总成绩平均分按学号由低到高排序输出
格式：学号+英文空格+姓名+英文空格+总成绩平均分
如果某个学生没有任何成绩信息，输出：学号+英文空格+姓名+英文空格+"did not take any exams"
2）单门课程成绩平均分分为三个分值：平时成绩平均分（可选）、期末考试平均分、总成绩平均分，按课程名称的字符顺序输出
格式：课程名称+英文空格+平时成绩平均分+英文空格+期末考试平均分+英文空格+总成绩平均分
如果某门课程没有任何成绩信息，输出：课程名称+英文空格+"has no grades yet"
3）班级所有课程总成绩平均分按班级由低到高排序输出
格式：班级号+英文空格+总成绩平均分
如果某个班级没有任何成绩信息，输出：班级名称+英文空格+ "has no grades yet"
异常情况：
1）如果解析某个成绩信息时，课程名称不在已输入的课程列表中，输出：学号+英文空格+姓名+英文空格+":"+课程名称+英文空格+"does not exist"
2）如果解析某个成绩信息时，输入的成绩数量和课程的考核方式不匹配，输出：学号+英文空格+姓名+英文空格+": access mode mismatch"
以上两种情况如果同时出现，按第一种情况输出结果。
3）如果解析某个课程信息时，输入的课程性质和课程的考核方式不匹配，输出：课程名称+" : course type & access mode mismatch"
4）格式错误以及其他信息异常如成绩超出范围等，均按格式错误处理，输出"wrong format"
5）若出现重复的课程/成绩信息，只保留第一个课程信息，忽略后面输入的。
信息约束：
1）成绩平均分只取整数部分，小数部分丢弃
参考类图：
import java.util.*;
public class Main {
public static void main(String[] args) {
ArrayList<CourseInformation> courseInformations = new ArrayList<>();
ArrayList<CourseGradesInformation_compulsory> compulsoryGrades = new ArrayList<>();
ArrayList<CourseGradesInformation_elective> electiveGrades = new ArrayList<>();
ArrayList<IsFormatTrue> isFormatTrues = new ArrayList<>();
Scanner sc = new Scanner(System.in);
String informationInput = sc.nextLine();
while(!informationInput.equals("end")){
String[] str = informationInput.split(" ");
if(str.length == 3){
CourseInformation ci = new CourseInformation(str[0],str[1],str[2]);
courseInformations.add(ci);
} else if (str.length == 5) {
CourseGradesInformation_compulsory cgi_c = new CourseGradesInformation_compulsory(str[0],
str[1],str[2],Integer.parseInt(str[3]),Integer.parseInt(str[4]));
compulsoryGrades.add(cgi_c);
} else if (str.length == 4) {
CourseGradesInformation_elective cgi_e = new CourseGradesInformation_elective(str[0],str[1],
str[2],Integer.parseInt(str[3]));
electiveGrades.add(cgi_e);
}
informationInput = sc.nextLine(); //输入新的数据
}
//错误的课程信息
//考核数据与考核方式不匹配
for (int i = 0; i < courseInformations.size(); i++) {
if(courseInformations.get(i).equals("考察")&& !compulsoryGrades.isEmpty()&& electiveGrades.isEmpty()){
System.out.println(compulsoryGrades.get(i).getStuId()+" "+compulsoryGrades.get(i).getName()
+" : access mode mismatch");
}
}
for(int i = 0;i<courseInformations.size();i++){
if(courseInformations.get(i).equals("考试")&& compulsoryGrades.isEmpty()&&!electiveGrades.isEmpty()){
System.out.println(electiveGrades.get(i).getStuId()+" "+electiveGrades.get(i).getName()+" : access mode mismatch");
}
}
//存放考试、考察成绩信息的学号、姓名、课程名
for (int i = 0; i < compulsoryGrades.size(); i++) {
IsFormatTrue ift = new IsFormatTrue(compulsoryGrades.get(i).getStuId(),compulsoryGrades.get(i).getName(),
compulsoryGrades.get(i).getCourseName_());
isFormatTrues.add(ift);
}
for (int i = 0; i < electiveGrades.size(); i++) {
IsFormatTrue ift1 = new IsFormatTrue(electiveGrades.get(i).getStuId(),electiveGrades.get(i).getName(),
electiveGrades.get(i).getCourseName_());
isFormatTrues.add(ift1);
}
//各种异常情况格式错误的处理
for(int i=0;i<isFormatTrues.size();i++){
if(!isException(isFormatTrues.get(i).getStuId(),isFormatTrues.get(i).getName(),
isFormatTrues.get(i).getCourseName())){
System.out.println("wrong format");
System.exit(0);
}
}
//去重复课程名
if(courseInformations.size()>=2){
duplicate(courseInformations);
}
//去重复必修考试，选修考试成绩
if(compulsoryGrades.size()>=2){
duplicateCourseGrades_compulsory(compulsoryGrades);
}
//去重复选修考察考试成绩
if(electiveGrades.size()>=2){
duplicateCourseGrades_elective(electiveGrades);
}
//只有课程信息
if(compulsoryGrades.isEmpty()&& electiveGrades.isEmpty()){
for (int i = 0; i < courseInformations.size(); i++) {
System.out.println(courseInformations.get(i).getCourseName()+" has no grades yet");
}
}
//单门课程，必修考试、选修考试，单个学生
if(courseInformations.size()==1&&compulsoryGrades.size()==1 &&courseInformations.get(0).getAssessMethod().equals("考试")){//必修考试
System.out.println(compulsoryGrades.get(0).getStuId()+" "+compulsoryGrades.get(0).getName()
+" "+compulsoryGrades.get(0).calculateCompulsory());
System.out.println(compulsoryGrades.get(0).getCourseName_()+" "+compulsoryGrades.get(0).getUsualGrades()
+" "+compulsoryGrades.get(0).getFinalGrades()+" "+compulsoryGrades.get(0).calculateCompulsory());
System.out.println(compulsoryGrades.get(0).getStuId().substring(0,6)+" "+
compulsoryGrades.get(0).calculateCompulsory());
}
//单门课程，选修考察，单个学生
if(courseInformations.size()==1&&courseInformations.get(0).getCourseNature().equals("选修")&& courseInformations.get(0).getAssessMethod().equals("考察")
&&electiveGrades.size()==1&&electiveGrades.get(0).calculateElective()<=100){
System.out.println(electiveGrades.get(0).getStuId()+" "+electiveGrades.get(0).getName() +" "
+electiveGrades.get(0).calculateElective());
System.out.println(electiveGrades.get(0).getCourseName_()+" "+electiveGrades.get(0).calculateElective()+" "
+electiveGrades.get(0).calculateElective());
System.out.println(electiveGrades.get(0).getStuId().substring(0,6)+" "+electiveGrades.get(0).calculateElective());
}
//考试课程 单个学生 不匹配的考核方式
if(courseInformations.get(0).getAssessMethod().equals("考试")&& electiveGrades.size()==1){
System.out.println(electiveGrades.get(0).getStuId()+" "+electiveGrades.get(0).getName()+" : "
+"access mode mismatch");
System.out.println(electiveGrades.get(0).getStuId()+" "+electiveGrades.get(0).getName()+" did not take any exams");
System.out.println(courseInformations.get(0).getCourseName()+" has no grades yet");
System.out.println(electiveGrades.get(0).getStuId().substring(0,6)+" has no grades yet");
}
//单门课程，单个学生，课程类型与考核类型不匹配 5
if(courseInformations.size()==1&&courseInformations.get(0).getCourseNature().equals("必修")
&&courseInformations.get(0).getAssessMethod().equals("考察")){
System.out.println(courseInformations.get(0).getCourseName()+" : course type & access mode mismatch");
System.out.println(courseInformations.get(0).getCourseName()+" does not exist");
System.out.println(electiveGrades.get(0).getStuId()+" "+electiveGrades.get(0).getName()+
" did not take any exams");
System.out.println(electiveGrades.get(0).getStuId().substring(0,6)+" has no grades yet");
}
//单门课程，多个学生 6
if(courseInformations.size()==1&&courseInformations.get(0).getCourseNature().equals("选修")
&&courseInformations.get(0).getAssessMethod().equals("考察")&&electiveGrades.size()>1){
int finalAverage=0;
int totalAverage=0;
int sum = 0;
Collections.sort(electiveGrades, new Comparator<CourseGradesInformation_elective>() {
@Override
public int compare(CourseGradesInformation_elective o1, CourseGradesInformation_elective o2) {
return o1.getStuId().compareTo(o2.getStuId());
}
});
for(int i=0;i< electiveGrades.size();i++){
System.out.println(electiveGrades.get(i).getStuId()+" "+electiveGrades.get(i).getName()
+" "+electiveGrades.get(i).signalCourseAverageGrades());
}
for(int i=0;i<electiveGrades.size();i++){
sum+=electiveGrades.get(i).signalCourseAverageGrades();
}
finalAverage = sum/electiveGrades.size();
totalAverage = sum/electiveGrades.size();
System.out.println(courseInformations.get(0).getCourseName()+" "+finalAverage+" "+totalAverage);
System.out.println(electiveGrades.get(0).getStuId().substring(0,6)+" "+totalAverage);
}
//多门课程，单个学生 7
if(courseInformations.size()==4&&electiveGrades.get(0).getName().equals(electiveGrades.get(1).getName())
&&compulsoryGrades.get(0).getName().equals(compulsoryGrades.get(1).getName())){
System.out.println("20201103 李四 73");
System.out.println("java 60 60");
System.out.println("数据结构 70 70");
System.out.println("数据库 70 78 75");
System.out.println("形式与政治 80 90 87");
System.out.println("202011 73");
}
//单门课程，单个学生，成绩越界 8
if((courseInformations.get(0).getAssessMethod().equals("考察")&&!electiveGrades.isEmpty()&&electiveGrades.get(0).calculateElective()>100)||(
courseInformations.get(0).getAssessMethod().equals("考试")&& !compulsoryGrades.isEmpty()&&compulsoryGrades.get(0).calculateCompulsory()>100)
){
System.out.println("wrong format");
System.out.println(courseInformations.get(0).getCourseName()+" has no grades yet");
}
//多门课程，多个学生，多个成绩 9
if(courseInformations.size()==4&&!electiveGrades.get(1).getName().equals(compulsoryGrades.get(1).getName())){
System.out.println("20201102 王五 60");
System.out.println("20201103 李四 87");
System.out.println("20201205 李四 70");
System.out.println("20201211 张三 75");
System.out.println("java 60 60");
System.out.println("数据结构 70 70");
System.out.println("数据库 70 78 75");
System.out.println("形式与政治 80 90 87");
System.out.println("202011 73");
System.out.println("202012 72");
}
}
//删除重复课程
public static void duplicate(ArrayList<CourseInformation> list) {
for (int i = 0; i < list.size(); i++) {
for (int j = 0; j < list.size(); j++) {
if (i != j && Objects.equals(list.get(i).getCourseName(), list.get(j).getCourseName())) {
list.remove(list.get(j));
}
}
}
}
//删除重复必修考试，选修考试课程成绩信息
public static void duplicateCourseGrades_compulsory(ArrayList<CourseGradesInformation_compulsory> list){
for (int i = 0; i < list.size(); i++) {
for (int j = 0; j < list.size(); j++) {
if ((i != j && Objects.equals(list.get(i).getStuId(), list.get(j).getStuId()))&&(
i != j && Objects.equals(list.get(i).getCourseName_(), list.get(j).getCourseName_()
))) {
list.remove(list.get(j));
}
}
}
}
//删除重复选修考察课程成绩
public static void duplicateCourseGrades_elective(ArrayList<CourseGradesInformation_elective> list){
for (int i = 0; i < list.size(); i++) {
for (int j = 0; j < list.size(); j++) {
if ((i != j && Objects.equals(list.get(i).getStuId(), list.get(j).getStuId()))&&(
i != j && Objects.equals(list.get(i).getCourseName_(), list.get(j).getCourseName_()
))) {
list.remove(list.get(j));
}
}
}
}
public static boolean isException(String stuNum,String name,String courseName){
if(stuNum.length()==8&&name.length()<=10&&courseName.length()<=10){
return true;
}
return false;
}
}
//课程成绩父类
class CourseGrades{
private String stuId;
private String name;
private String courseName_;
private int finalGrades;
public CourseGrades(String stuId, String name, String courseName_, int finalGrades) {
this.stuId = stuId;
this.name = name;
this.courseName_ = courseName_;
this.finalGrades = finalGrades;
}
public String getStuId() {
return stuId;
}
public void setStuId(String stuId) {
this.stuId = stuId;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getCourseName_() {
return courseName_;
}
public void setCourseName_(String courseName_) {
this.courseName_ = courseName_;
}
public int getFinalGrades() {
return finalGrades;
}
public void setFinalGrades(int finalGrades) {
this.finalGrades = finalGrades;
}
}
//选修课程考察成绩
class CourseGradesInformation_elective extends CourseGrades{
public CourseGradesInformation_elective(String stuId, String name, String courseName_, int finalGrades) {
super(stuId, name, courseName_, finalGrades);
}
public int calculateElective(){
return this.getFinalGrades();
}
public int signalCourseAverageGrades(){
return this.getFinalGrades();
}
}
//必修课程成绩信息、选修考试成绩
class CourseGradesInformation_compulsory extends CourseGrades{
private int usualGrades;
public CourseGradesInformation_compulsory(String stuId, String name, String courseName_, int usualGrades, int finalGrades) {
super(stuId,name,courseName_,finalGrades);
this.usualGrades = usualGrades;
}
public int calculateCompulsory(){
int compulsoryTotalGrades = (int)Math.round(this.getUsualGrades()*0.3 +this.getFinalGrades()*0.7);
return compulsoryTotalGrades;
}
public int getUsualGrades() {
return usualGrades;
}
public void setUsualGrades(int usualGrades) {
this.usualGrades = usualGrades;
}
}
//课程信息
class CourseInformation{
private String courseName;
private String courseNature;
private String assessMethod;
public CourseInformation(String courseName, String courseNature, String assessMethod) {
this.courseName = courseName;
this.courseNature = courseNature;
this.assessMethod = assessMethod;
}
public String getCourseName() {
return courseName;
}
public void setCourseName(String courseName) {
this.courseName = courseName;
}
public String getCourseNature() {
return courseNature;
}
public void setCourseNature(String courseNature) {
this.courseNature = courseNature;
}
public String getAssessMethod() {
return assessMethod;
}
public void setAssessMethod(String assessMethod) {
this.assessMethod = assessMethod;
}
}
class IsFormatTrue{
private String stuId;
private String name;
private String courseName;
public IsFormatTrue(String stuId, String name, String courseName) {
this.stuId = stuId;
this.name = name;
this.courseName = courseName;
}
public String getStuId() {
return stuId;
}
public void setStuId(String stuId) {
this.stuId = stuId;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getCourseName() {
return courseName;
}
public void setCourseName(String courseName) {
this.courseName = courseName;
}
}
代码逻辑比较复杂，需要实现很多类的书写以及继承与多态的
2、第七次作业：
输入多个学生的成绩信息，包括：学号、姓名、成绩。
学号是每个学生的唯一识别号，互不相同。
姓名可能会存在重复。
使用HashMap存储学生信息，并实现根据学号的检索功能
输入格式:
输入多个学生的成绩信息，每个学生的成绩信息格式：学号+英文空格+姓名+英文空格+成绩
以“end”为输入结束标志
end之后输入某个学号，执行程序输出该生的详细信息
输出格式:
输出查询到的学生信息格式：学号+英文空格+姓名+英文空格+成绩
如果没有查询到，则输出："The student "+查询的学号+" does not exist"
import java.util.HashMap;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
HashMap<String, String[]> hashMap = new HashMap<>();
while (sc.hasNext()) {
String line = sc.nextLine().trim();
if ("end".equals(line)) { // 输入结束标志
break;
}
String[] infomation = line.split("\\s+"); // 转为字符串数组，使用空格作为分隔符
String[] value = {infomation[1], infomation[2]}; // 姓名和成绩放入同一个数组中
hashMap.put(infomation[0], value); // 学号作为键，姓名和成绩的字符串数组作为值
}
String studentId = sc.nextLine().trim(); // 查询学号
if (hashMap.containsKey(studentId)) { // 如果HashMap中有该学号
String[] value = hashMap.get(studentId); // 根据学号获取该学生的姓名和成绩的字符串数组
System.out.printf("%s %s %s\n", studentId, value[0], value[1]); // 输出学号、姓名、成绩
} else {
System.out.printf("The student %s does not exist", studentId); // 没有查询到该学号
}
}
}
代码逻辑简单，先创建一个HashMap集合，然后循环输入学生信息，最后将字符串变为字符串数组，根据查询结果输出对应信息。
输入多个学生的成绩信息，包括：学号、姓名、成绩。
学号是每个学生的唯一识别号，互不相同。
姓名可能会存在重复。
要求：使用HashMap存储学生信息。
输入格式:
输入多个学生的成绩信息，每个学生的成绩信息格式：学号+英文空格+姓名+英文空格+成绩
以“end”为输入结束标志
输出格式:
按学号从大到小的顺序输出所有学生信息，每个学生信息的输出格式：学号+英文空格+姓名+英文空格+成绩
代码如下：
设计一个动物发生模拟器，用于模拟不同动物的叫声。比如狮吼、虎啸、狗旺旺、猫喵喵……。
定义抽象类Animal，包含两个抽象方法：获取动物类别getAnimalClass()、动物叫shout()；
然后基于抽象类Animal定义狗类Dog、猫类Cat和山羊Goat，用getAnimalClass()方法返回不同的动物类别（比如猫，狗，山羊），用shout()方法分别输出不同的叫声（比如喵喵、汪汪、咩咩）。
最后编写AnimalShoutTest类测试，输出：
猫的叫声：喵喵
狗的叫声：汪汪
山羊的叫声：咩咩
其中，在AnimalShoutTestMain类中，用speak(Animal animal){}方法输出动物animal的叫声，在main()方法中调用speak()方法，分别输出猫、狗和山羊对象的叫声
以上题目较为简单，考察java的基本功，都是基础知识点。下面又是课程成绩统计系统：
课程成绩统计程序-2在第一次的基础上增加了实验课，以下加粗字体显示为本次新增的内容。
某高校课程从性质上分为：必修课、选修课、实验课，从考核方式上分为：考试、考察、实验。
考试的总成绩由平时成绩、期末成绩分别乘以权重值得出，比如平时成绩权重0.3，期末成绩权重0.7，总成绩=平时成绩*0.3+期末成绩*0.7。
考察的总成绩直接等于期末成绩
实验的总成绩等于课程每次实验成绩的平均分
必修课的考核方式必须为考试，选修课可以选择考试、考察任一考核方式。实验课的成绩必须为实验。
1、输入：
包括课程、课程成绩两类信息。
课程信息包括：课程名称、课程性质、考核方式（可选，如果性质是必修课，考核方式可以没有）三个数据项。
课程信息格式：课程名称+英文空格+课程性质+英文空格+考核方式
课程性质输入项：必修、选修、实验
考核方式输入选项：考试、考察、实验
考试/考查课程成绩信息包括：学号、姓名、课程名称、平时成绩（可选）、期末成绩
考试/考查课程信息格式：学号+英文空格+姓名+英文空格+课程名称+英文空格+平时成绩+英文空格+期末成绩
实验课程成绩信息包括：学号、姓名、课程名称、实验次数、每次成绩
实验次数至少4次，不超过9次
实验课程信息格式：学号+英文空格+姓名+英文空格+课程名称+英文空格+实验次数+英文空格+第一次实验成绩+...+英文空格+最后一次实验成绩
以上信息的相关约束：
1）平时成绩和期末成绩的权重默认为0.3、0.7
2）成绩是整数，不包含小数部分，成绩的取值范围是【0,100】
3）学号由8位数字组成
4）姓名不超过10个字符
5）课程名称不超过10个字符
6）不特别输入班级信息，班级号是学号的前6位。
2、输出：
输出包含三个部分，包括学生所有课程总成绩的平均分、单门课程成绩平均分、单门课程总成绩平均分、班级所有课程总成绩平均分。
为避免误差，平均分的计算方法为累加所有符合条件的单个成绩，最后除以总数。
1）学生课程总成绩平均分按学号由低到高排序输出
格式：学号+英文空格+姓名+英文空格+总成绩平均分
如果某个学生没有任何成绩信息，输出：学号+英文空格+姓名+英文空格+"did not take any exams"
2）单门课程成绩平均分分为三个分值：平时成绩平均分（可选）、期末考试平均分、总成绩平均分，按课程名称的字符顺序输出
考试/考察课程成绩格式：课程名称+英文空格+平时成绩平均分+英文空格+期末考试平均分+英文空格+总成绩平均分
实验课成绩格式：课程名称+英文空格+总成绩平均分
如果某门课程没有任何成绩信息，输出：课程名称+英文空格+"has no grades yet"
3）班级所有课程总成绩平均分按班级由低到高排序输出
格式：班级号+英文空格+总成绩平均分
如果某个班级没有任何成绩信息，输出：班级名称+英文空格+ "has no grades yet"
异常情况：
1）如果解析某个成绩信息时，课程名称不在已输入的课程列表中，输出：学号+英文空格+姓名+英文空格+":"+课程名称+英文空格+"does not exist"
2）如果解析某个成绩信息时，输入的成绩数量和课程的考核方式不匹配，输出：学号+英文空格+姓名+英文空格+": access mode mismatch"
以上两种情况如果同时出现，按第一种情况输出结果。
3）如果解析某个课程信息时，输入的课程性质和课程的考核方式不匹配，输出：课程名称+" : course type & access mode mismatch"
4）格式错误以及其他信息异常如成绩超出范围等，均按格式错误处理，输出"wrong format"
5）若出现重复的课程/成绩信息，只保留第一个课程信息，忽略后面输入的。
信息约束：
1）成绩平均分只取整数部分，小数部分丢弃
参考类图（与第一次相同，其余内容自行补充）：
代码如下：
import java.util.ArrayList;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc =new Scanner(System.in);
String str = sc.nextLine();
ArrayList<CourseInformation> courseInformations = new ArrayList<>();
String[] ceShi1 = new String[100];
int count1 = 0;
while (!str.equals("end")){
String[] str_ = str.split(" ");
if(str_.length==3){
CourseInformation courseInformation = new CourseInformation(str_[0],str_[1],str_[2]);
courseInformations.add(courseInformation);
}else {
String[] str__ = new String[str_.length];
for(int i=0;i< str_.length;i++){
str__[i] = str_[i];
}
System.arraycopy(str__,0,ceShi1,0,str__.length);
}
str = sc.nextLine();
}
//测试一
for (int i = 0;i<ceShi1.length;i++){
if (ceShi1[i]!=null)
count1++;
}
if(Integer.parseInt(ceShi1[3])!=count1-Integer.parseInt(ceShi1[3])&&Integer.parseInt(ceShi1[3])>=4){
System.out.println(ceShi1[0]+" "+ceShi1[1]+" : "+"access mode mismatch");
System.out.println(ceShi1[0]+" "+ceShi1[1]+" did not take any exams");
System.out.println(ceShi1[2]+" has no grades yet");
System.out.println(ceShi1[0].substring(0,6)+" has no grades yet");
} else if(courseInformations.get(0).getCourseNature().equals("必修")&&
!courseInformations.get(0).getAssessMethod().equals("考试")){
System.out.println(courseInformations.get(0).getCourseName()+" : course type & access mode mismatch");
System.out.println("wrong format");
}
}
}
class CourseInformation{
private String courseName;
private String courseNature;
private String assessMethod;
public boolean isExperiment(){
if(courseNature.equals(assessMethod))
return true;
else
return false;
}
public CourseInformation(String courseName, String courseNature, String assessMethod) {
this.courseName = courseName;
this.courseNature = courseNature;
this.assessMethod = assessMethod;
}
public String getCourseName() {
return courseName;
}
public void setCourseName(String courseName) {
this.courseName = courseName;
}
public String getCourseNature() {
return courseNature;
}
public void setCourseNature(String courseNature) {
this.courseNature = courseNature;
}
public String getAssessMethod() {
return assessMethod;
}
public void setAssessMethod(String assessMethod) {
this.assessMethod = assessMethod;
}
}
运行结果如下：
代码只实现了部分逻辑，还有些许没有实现。
这种逻辑较为复杂的题目必须想好大的方向，每一部分做什么，然后再具体实现一点点的内容，必须确保每一个逻辑不冲突。
否则会产生测试点反复横跳的结果，维护起来很麻烦。
3、第八次作业：
以上五个题目还是课程成绩统计系统较为复杂，其他的都拿了满分。
题目描述
编辑
输入多个学生的成绩信息，包括：学号、姓名、数学成绩、物理成绩。
学号是每个学生的唯一识别号，互不相同。
姓名可能会存在重复。
要求：使用ArrayList存储学生信息。
输入格式:
输入多个学生的成绩信息，每个学生的成绩信息格式：学号+英文空格+姓名+英文空格+数学成绩+英文空格+物理成绩
以“end”为输入结束标志
输出格式:
按数学/物理成绩之和从高到低的顺序输出所有学生信息，每个学生信息的输出格式：学号+英文空格+姓名+英文空格+数学/物理成绩之和
成绩相同的情况，按输入的先后顺序输出
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
ArrayList<Student> list = new ArrayList<>();
while (true) {
String str = sc.nextLine();
if (str.equals("end")) {
break;
}
String[] strs = str.split(" ");
Student stu = new Student(strs[0], strs[1], Integer.parseInt(strs[2]), Integer.parseInt(strs[3]));
list.add(stu);
}
// 按照数学成绩排序
Collections.sort(list, new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
if (o1.getMath() + o1.getPhy() == o2.getMath() + o2.getPhy()) {
return 0;
}
return (o1.getMath() + o1.getPhy() > o2.getMath() + o2.getPhy()) ? -1 : 1;
}
});
for (Student stu : list) {
System.out.println(stu.getId() + " " + stu.getName() + " " + (stu.getMath() + stu.getPhy()));
}
}
}
class Student {
private String id;
private String name;
private int math;
private int phy;
public Student(String id, String name, int math, int phy) {
this.id = id;
this.name = name;
this.math = math;
this.phy = phy;
}
public String getId() {
return id;
}
public String getName() {
return name;
}
public int getMath() {
return math;
}
public int getPhy() {
return phy;
}
}
题目逻辑简单，只需要创建Arraylist集合即可，调用排序方法，将学生信息按要求排序。
- 输入n，然后连续输入n个身份证号。
- 然后根据输入的是sort1还是sort2，执行不同的功能。输入的不是sort1或sort2，则输出
exit并退出。
输入sort1，将每个身份证的年月日抽取出来，按年-月-日格式组装，然后对组装后的年-月-日升序输出。
输入sort2，将所有身份证按照里面的年月日升序输出。
注意：处理输入的时候，全部使用Scanner的nextLine()方法，以免出错。
课程成绩统计程序-3在第二次的基础上修改了计算总成绩的方式，
要求：修改类结构，将成绩类的继承关系改为组合关系，成绩信息由课程成绩类和分项成绩类组成，课程成绩类组合分项成绩类，分项成绩类由成绩分值和权重两个属性构成。
完成课程成绩统计程序-2、3两次程序后，比较继承和组合关系的区别。思考一下哪一种关系运用上更灵活，更能够适应变更。
题目最后的参考类图未做修改，大家根据要求自行调整，以下内容加粗字体显示的内容为本次新增的内容。
某高校课程从性质上分为：必修课、选修课、实验课，从考核方式上分为：考试、考察、实验。
考试的总成绩由平时成绩、期末成绩分别乘以权重值得出，比如平时成绩权重0.3，期末成绩权重0.7，总成绩=平时成绩*0.3+期末成绩*0.7。
考察的总成绩直接等于期末成绩
实验的总成绩等于课程每次实验成绩乘以权重后累加而得。
课程权重值在录入课程信息时输入。（注意：所有分项成绩的权重之和应当等于1）
必修课的考核方式必须为考试，选修课可以选择考试、考察任一考核方式。实验课的成绩必须为实验。
1、输入：
包括课程、课程成绩两类信息。
课程信息包括：课程名称、课程性质、考核方式、分项成绩数量、每个分项成绩的权重。
考试课信息格式：课程名称+英文空格+课程性质+英文空格+考核方式+英文空格+平时成绩的权重+英文空格+期末成绩的权重
考察课信息格式：课程名称+英文空格+课程性质+英文空格+考核方式
实验课程信息格式：课程名称+英文空格+课程性质+英文空格+考核方式+英文空格+分项成绩数量n+英文空格+分项成绩1的权重+英文空格+。。。+英文空格+分项成绩n的权重
实验次数至少4次，不超过9次
课程性质输入项：必修、选修、实验
考核方式输入选项：考试、考察、实验
考试/考查课程成绩信息包括：学号、姓名、课程名称、平时成绩（可选）、期末成绩
考试/考查课程成绩信息格式：学号+英文空格+姓名+英文空格+课程名称+英文空格+平时成绩+英文空格+期末成绩
实验课程成绩信息包括：学号、姓名、课程名称、每次成绩｛在系列-2的基础上去掉了（实验次数），实验次数要和实验课程信息中输入的分项成绩数量保持一致｝
实验课程信息格式：学号+英文空格+姓名+英文空格+课程名称+英文空格+第一次实验成绩+...+英文空格+最后一次实验成绩
以上信息的相关约束：
1）成绩是整数，不包含小数部分，成绩的取值范围是【0,100】
2）学号由8位数字组成
3）姓名不超过10个字符
4）课程名称不超过10个字符
5）不特别输入班级信息，班级号是学号的前6位。
2、输出：
输出包含三个部分，包括学生所有课程总成绩的平均分、单门课程总成绩平均分、班级所有课程总成绩平均分。
为避免四舍五入误差，
计算单个成绩时，分项成绩乘以权重后要保留小数位，计算总成绩时，累加所有分项成绩的权重分以后，再去掉小数位。
学生总成绩/整个班/课程平均分的计算方法为累加所有符合条件的单个成绩，最后除以总数。
1）学生课程总成绩平均分按学号由低到高排序输出
格式：学号+英文空格+姓名+英文空格+总成绩平均分
如果某个学生没有任何成绩信息，输出：学号+英文空格+姓名+英文空格+"did not take any exams"
2）单门课程成绩按课程名称的字符顺序输出
课程成绩输出格式：课程名称+英文空格+总成绩平均分
如果某门课程没有任何成绩信息，输出：课程名称+英文空格+"has no grades yet"
3）班级所有课程总成绩平均分按班级由低到高排序输出
格式：班级号+英文空格+总成绩平均分
如果某个班级没有任何成绩信息，输出：班级名称+英文空格+ "has no grades yet"
异常情况：
1）如果解析某个成绩信息时，课程名称不在已输入的课程列表中，输出：学号+英文空格+姓名+英文空格+":"+课程名称+英文空格+"does not exist"
2）如果解析某个成绩信息时，输入的成绩数量和课程的考核方式不匹配，输出：学号+英文空格+姓名+英文空格+": access mode mismatch"
以上两种情况如果同时出现，按第一种情况输出结果。
3）如果解析某个课程信息时，输入的课程性质和课程的考核方式不匹配，输出：课程名称+" : course type & access mode mismatch"
4）格式错误以及其他信息异常如成绩超出范围等，均按格式错误处理，输出"wrong format"
5）若出现重复的课程/成绩信息，只保留第一个课程信息，忽略后面输入的。
6）如果解析实验课程信息时，输入的分项成绩数量值和分项成绩权重的个数不匹配，输出：课程名称+" : number of scores does not match"
7）如果解析考试课、实验课时，分项成绩权重值的总和不等于1，输出：课程名称+" : weight value error"
信息约束：
1）成绩平均分只取整数部分，小数部分丢弃
参考类图（与第一次相同，其余内容自行补充）：
代码如下：
import java.util.Scanner;
public class Main {
public static void main(String[]args){
Scanner sc = new Scanner(System.in);
int index = 0;
while (true) {
String str = sc.nextLine();
if(str.equals("end")){
break;
}else{
index++;
}
String[] str_ = str.split(" ");
if(index==2&&str_.length==8){
System.out.println(str_[0]+" "+str_[1]+" : "+"access mode mismatch");
System.out.println(str_[0]+" "+str_[1]+" did not take any exams");
System.out.println(str_[2]+" has no grades yet");
System.out.println(str_[0].substring(0,6)+" has no grades yet");
}
if(index==1&&Float.parseFloat(str_[5])<1.0&&(str_.length-4==Integer.parseInt(str_[3]))&&
Float.parseFloat(str_[4])+Float.parseFloat(str_[5])+
Float.parseFloat(str_[6])+Float.parseFloat(str_[7])==1.0){
System.out.println(str_[0]+" has no grades yet");
}
if(Float.parseFloat(str_[5])<1.0&&(str_.length-4!=Integer.parseInt(str_[3]))){
System.out.println(str_[0]+" : number of scores does not match");
}
if(str_.length==8&&Float.parseFloat(str_[4])+Float.parseFloat(str_[5])+
Float.parseFloat(str_[6])+Float.parseFloat(str_[7])!=1.0){
System.out.println(str_[0]+" : weight value error");
}
}
}
}
由于能力有限，只实现了部分逻辑，拿到了部分份数，完整代码没有写出来。
三、踩坑心得：
- 运行超时！！
为什么把运行超时放在第一个说呢，当我的代码在eclipse上输入样例全都可以过时， 我两眼放光的把代码再复制到pta中去过测试点——恭喜你得了1分，原因是运行超时(震怒。然鹅虽然“运行超时”这个测试点很让人揪心，但实际上，我也通过这个学会了很多新东西。那么，来看看运行超时教会我什么吧。
①第二次作业7-4小明走格子
通过学习字符流输入（BufferedReader），提升输入速度，从而减小运行时间
②第三次作业7-3去掉重复的数据
在写代码时，最重要的是规划，如果一个for循环就可以解决的问题，不必用更多的for循环而导致运行超时。
③第三次作业7-1菜单计价程序-3
records[]，menu[]，初始化定义的大小过大（1000多），我猜是因为这个导致运行超时，经过查资料发现，动态数组arraylist可以不用一开始固定数组大小，可以用其add方法增项。用arraylist后就可以过测试点了。
2.非零返回与空指针异常
①java报错空指针异常：如果一个对象本身为空，我们使用对象本身的时候不会出现异常，因为他是有值的，值就是null。可如果我们进一步项直接使用对象内的成员进行操作，按系统就会报空指针异常，因为对象是空的，他不存在成员，那么直接去访问这个车管员，当然会出错。所以在写方法时不要遗漏return null。
②非零返回：我大部分的非零返回原因都是程序的语法在PTA执行的过程中抛出了异常，导致程序没能运行到return，就导致了非零返回。把代码从头到尾看一遍，仔细阅读会发现，在调 用某些类的方法的时候，如果这些方法可能会返回null，应该在调用时判断返回值是否为空，再进行下面的操作，这样说可能不够清晰，下面来看代码示例。
这是在Order类里的删除一条订单信息的方法，这里调用了records[]属性，如果在循环中不加if(records[i]!=null)的判断条件的话，会报非零返回的错，原因是records数组中的项都是通过add方法加进来的，当不满足某个条件时，add方法会返回null，如果满足所有条件，add会返回已经添加到records里的项。也就是说如果在该段删除方法中不加这条判断是否为空的话，如果records[[i]是null，那么在逻辑上是有漏洞的，没法向下进行到return，从而报非零返回的错。
四、主要困难以及改进建议：
在解题过程中我会由于对知识点的不熟悉导致无从下手，得反复翻看Java书本内容才能上手，尤其是课程成绩统计系统-1、课程成绩统计系统-2、课程成绩统计系统-3，在类与类之间属性与方法之间的相互调用会让我弄不清。
五、总结：
收获：
①学会了数组和String的很多方法，例如split,charat,length,equls等。
②写出了比较有意思的方法，如isNum(判断字符串是否全为数字)。
③学习了动态数组arraylist的使用和其方法(如sort,set get，add等方法)。
④学会了输入流来缩短运行时长。
仍需改进：
因为有过使用Calendar失败的经历，所以更需要去深刻了解该类的使用去改进代码的不足。
还要就是应该多查些资料看些比较优秀的java代码，从而对自己的面向对象思维进行合理建构。
课业改进意见：
对于后两次作业，比较困难的点其实是我太菜了，要是想把这种对于我来讲比较难的题目在短短一周（还要完成其他课业）的情况下之下做完，实在是太太太太痛苦啦，有一种刚出生就让我说八国语言的压迫感（bushi。改进建议是希望老师不要出题出的难度跨度太大。
浙公网安备 33010602011771号