标签：return String int public JavaBlog id name

前言

　　第三次也是最后博客文章主要是关于java课程第三阶段关于PTA题目集、超星作业以及在实验平台上布置的一些题型。相较于第一、二阶段的作业总结而言此次作业更加针对于总结在面向对象过程中的三大技术特性，即封装性、继承性和多态性，类图的设计更加普遍。在不断深入学习Java的过程又延伸到了Javafx，在这个阶段也挺有趣的，不仅能把图片放在窗口还可以通过Java代码的撰写做出很多好玩的小程序。通过学习类属性的访问权限，了解到了四种访问权限：public，private，protected，default；以及不同类的类型：实体类，业务类，接口类；对于类设计上，学习的多，代表思路与编程思想变得更为开阔且严谨，开始真正考虑到如何将一个题目设计到恰如其分，不同的设计思路带来的不同效果。

设计与分析

　　第三阶段的作业次数与第一、二阶段是一样的，一共有三次，但相比较于第二个，本阶段作业难度有所提升，涉及到的也大多是继承和多态。本阶段的学习让我们还是主要了解了以下三个方面的内容：

1.正则表达式的简单使用。

2.面向对象的三大特性：封装性、继承性、多态性。

3.同时也了解了一些面向对象编程的原则：单一职责原则、开闭原则等。

　　同时通过可查阅的资料了解到类的继承与多态的特征与属性：关于继承与多态：面向对象的三大特征：封装性、继承性、多态性，继承是多态的前提，如果没有继承，就没有多态。

　　特点：
1、子类可以拥有父类的“内容”
2、子类还可以拥有自己专有的新内容
3、单继承：一个类的直接父类只能有唯一一个
4、可以多级继承，有多个子类。在继承关系当中，“子类就是一个父类”。也就是说，子类可以被当作父类看待

 

7-1 课程成绩统计程序-1

某高校课程从性质上分为：必修课、选修课，从考核方式上分为：考试、考察。

考试的总成绩由平时成绩、期末成绩分别乘以权重值得出，比如平时成绩权重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）成绩平均分只取整数部分，小数部分丢弃

类图如下：

通过该类图应该可以大致看出整个程序的大致类关系，和一对多、一对一关系，这道题目和之前的菜单程序有很多相似之处，输入是如此但是仍然没有拿到满分，很多测试点还是没能过，仅仅取得87的分数下面先展示下本次作业的代码：

 

  1 import java.util.*;
  2 
  3 public class Main {
  4     public static void main(String[] args) {
  5         Scanner in = new Scanner(System.in);
  6         List<String> list = new ArrayList<>();
  7         List<Student> students = new ArrayList<>();
  8         List<Clazz> classes = new ArrayList<>();
  9         List<Course> courses = new ArrayList<>();
 10         List<SelectCourse> selectCourses = new ArrayList<>();
 11 
 12         String str = in.nextLine();
 13         while(!str.equals("end")){
 14          //   if(!list.contains(str))
 15                 list.add(str);
 16             str = in.nextLine();
 17         }
 18         for(String s : list){
 19             String[] buff = s.split(" ");
 20             if(buff.length==2 || buff.length==3){ //该行是课程信息
 21                 Course course = null;
 22                 if(!Check.checkCourseName(buff[0]) || !Check.checkType(buff[1]) || (buff.length==2&&buff[1].equals("选修"))){
 23                     System.out.println("wrong format");
 24                     continue;
 25                 }
 26 
 27                 if(buff.length == 3){
 28                     course = new Course(buff[0],buff[1],buff[2]);
 29                     if(!Check.checkCourseMethod(buff[1],buff[2])){
 30                         System.out.println(buff[0]+" : course type & access mode mismatch");
 31                         continue;
 32                     }
 33                     if(!Check.checkMethod(buff[2])){
 34                         System.out.println("wrong format");
 35                         continue;
 36                     }
 37                 }else{
 38                     course  = new Course(buff[0],buff[1]);
 39                 }
 40 
 41                 if(!courses.contains(course)){
 42                     courses.add(course);
 43                 }
 44             }else if(buff.length == 4 || buff.length == 5){      //该行是成绩信息
 45                 if(!Check.checkScore(buff[3])){   //判断成绩范围是否符合标准
 46                     System.out.println("wrong format");
 47                     continue;
 48                 }
 49                 if(buff.length == 5){
 50                     if(!Check.checkScore(buff[4])){   //判断成绩范围是否符合标准
 51                         System.out.println("wrong format");
 52                         continue;
 53                     }
 54                 }
 55 
 56                 if(!Check.checkStudentId(buff[0])){     //判断学号是否符合标准
 57                     System.out.println("wrong format");
 58                     continue;
 59                 }
 60                 if(!Check.checkCourseName(buff[2]) || !Check.checkCourseName(buff[1])){ //判断课程名字和学生姓名是否符合标志
 61                     System.out.println("wrong format");
 62                     continue;
 63                 }
 64                 Student student = new Student(buff[0], buff[1]);
 65                 if(!students.contains(student)){    //防止重复添加学生
 66                     students.add(student);
 67                 }
 68 
 69                 Clazz clazz = new Clazz(buff[0].substring(0, 6));
 70                 if(!classes.contains(clazz)){       //防止重复添加班级
 71                     classes.add(clazz);
 72                 }
 73                 student.setCla(clazz);
 74 
 75                 if(!Check.checkCourse(courses, buff[2])){    //判断解析某个成绩信息时，课程名称是否在已输入的课程列表中
 76                     System.out.println(buff[2]+" does not exist");
 77                     continue;
 78                 }
 79                 Course course = Course.getCourseByName(courses,buff[2]);
 80                 if(!Check.checkCourseMethod(buff[1],buff[2])){      //判断课程性质和课程的考核方式是否匹配
 81                     System.out.println(buff[0]+" : course type & access mode mismatch");
 82                     continue;
 83                 }
 84 
 85                 if(!Check.checkCountScore(course,buff)){     //判断解析某个成绩信息时，输入的成绩数量和课程的考核方式是否匹配
 86                     System.out.println(buff[0]+" "+buff[1]+" : access mode mismatch");
 87                     continue;
 88                 }
 89                 Score score = null;
 90 
 91                 if(buff.length==4){
 92                     score = new InScore(Integer.parseInt(buff[3]));
 93                 }else if(buff.length==5){
 94                     score = new ExScore(Integer.parseInt(buff[3]),Integer.parseInt(buff[4]));
 95                 }
 96 
 97                 SelectCourse selectCourse = new SelectCourse(course,student,score);
 98 
 99                 if(!selectCourses.contains(selectCourse)){
100                     selectCourses.add(selectCourse);
101                 }
102             }
103             else
104                 System.out.println("wrong format");
105         }
106         for(Course course : courses) {
107             course.getTotalAvg(selectCourses);
108         }
109 
110         Collections.sort(students);
111         Collections.sort(courses);
112         Collections.sort(classes);
113 
114         for (Student student : students) {
115             student.print(selectCourses);
116         }
117 
118         for(Course course : courses) {
119             course.print(selectCourses);
120         }
121 
122         for(Clazz cla : classes) {
123             cla.print(selectCourses);
124         }
125 
126     }
127 }
128 
129 class Check {
130     public static boolean checkCourse(List<Course> courses, String name) {
131         for(Course course : courses){
132             if(course.getName().equals(name))
133                 return true;
134         }
135         return false;
136     }
137 
138     public static boolean checkCountScore(Course course, String[] buff) {
139         if(course.getMethod().equals("考试") && buff.length==5)
140             return true;
141         if(course.getMethod().equals("考察") && buff.length==4)
142             return true;
143         return  false;
144     }
145 
146     public static boolean checkCourseMethod(String str1, String str2) {
147         if(str1.equals("必修") && str2.equals("考察")){
148             return false;
149         }
150         return true;
151     }
152 
153     public static boolean checkScore(String score) {
154         String regex = "\\d+"; // 使用正则表达式匹配8位数字
155         if (!score.matches(regex)) {
156             return false;
157         }
158         if(Integer.parseInt(score)>100 || Integer.parseInt(score)<0)
159             return false;
160         return true;
161     }
162 
163     public static boolean checkCourseName(String name){
164         if(name.length() > 10){
165             return false;
166         }
167         return true;
168     }
169 
170     public static boolean checkStudentId(String id) {
171         String regex = "\\d{8}"; // 使用正则表达式匹配8位数字
172         if (id.matches(regex))
173             return true;
174         return false;
175     }
176 
177     public static boolean checkType(String t) {
178         if(t.equals("必修") || t.equals("选修"))
179             return true;
180         return false;
181     }
182 
183     public static boolean checkMethod(String m) {
184         if(m.equals("考试") || m.equals("考察"))
185             return true;
186         return false;
187     }
188 }
189 
190 class Clazz implements Comparable<Clazz> {
191     private String cla_id;
192 
193     public Clazz(String cla_id) {
194         this.cla_id = cla_id;
195     }
196 
197     public String getCla_id() {
198         return cla_id;
199     }
200 
201     public void setCla_id(String cla_id) {
202         this.cla_id = cla_id;
203     }
204 
205     public void print(List<SelectCourse> selectCourses){
206         if(selectCourses.isEmpty()){
207             System.out.println(this.cla_id+" has no grades yet");
208         }else{
209             System.out.println(this.cla_id+" "+getTotalAvg(selectCourses));
210         }
211     }
212     public int getTotalAvg(List<SelectCourse> selectCourses) {
213         double sum = 0;
214         int i = 0;
215         for(SelectCourse selectCourse: selectCourses){
216             if(selectCourse.getStudent().getCla().getCla_id().equals(this.cla_id)){
217                 sum+= selectCourse.getScore().getTotalScore();
218                 i++;
219             }
220 
221         }
222         return (int) Math.floor(sum/i);
223     }
224 
225     @Override
226     public boolean equals(Object obj) {
227         if (this == obj)
228             return true;
229         if (obj == null || getClass() != obj.getClass())
230             return false;
231         Clazz clazz = (Clazz) obj;
232         return Objects.equals(cla_id, clazz.cla_id);
233     }
234 
235     @Override
236     public int hashCode() {
237         return Objects.hash(cla_id);
238     }
239 
240 
241     @Override
242     public int compareTo(Clazz o) {
243         return this.cla_id.compareTo(o.cla_id);
244     }
245 }
246 
247 class Course implements Comparable<Course> {
248     private String name;
249     private String type; //性质
250     private String method; //考核方式
251     private int total;
252 
253     public Course(String name, String type) {
254         this.name = name;
255         this.type = type;
256     }
257     public Course(String name, String type, String method) {
258         this.name = name;
259         this.type = type;
260         this.method = method;
261     }
262 
263     public int getTotal() {
264         return total;
265     }
266 
267     public void setTotal(int total) {
268         this.total = total;
269     }
270 
271     public String getName() {
272         return name;
273     }
274 
275     public void setName(String name) {
276         this.name = name;
277     }
278 
279     public String getType() {
280         return type;
281     }
282 
283     public void setType(String type) {
284         this.type = type;
285     }
286 
287     public String getMethod() {
288         return method;
289     }
290 
291     public void setMethod(String method) {
292         this.method = method;
293     }
294 
295     public void print(List<SelectCourse> selectCourses){
296         if(selectCourses.isEmpty()){
297             System.out.println(this.name+" has no grades yet");
298             return;
299         }
300         if(this.method.equals("考察")){
301             System.out.println(name+" "+getEndAvg(selectCourses)+" "+getTotalAvg(selectCourses));
302         }else if(this.method.equals("考试")){
303             System.out.println(name+" "+getDailAvg(selectCourses)+" "+getEndAvg(selectCourses)+" "+getTotalAvg(selectCourses));
304         }
305 
306     }
307     public int getDailAvg(List<SelectCourse> selectCourses) {
308         double sum = 0;
309         int i = 0;
310         for(SelectCourse selectCourse: selectCourses){
311             if(selectCourse.getCourse().getName().equals(this.name)){
312                 sum+= selectCourse.getScore().getDailyScore();
313                 i++;
314             }
315         }
316         return (int) Math.floor(sum/i);
317     }
318 
319     public int getEndAvg(List<SelectCourse> selectCourses) {
320         double sum = 0;
321         int i = 0;
322         for(SelectCourse selectCourse: selectCourses){
323             if(selectCourse.getCourse().getName().equals(this.name)){
324                 sum+= selectCourse.getScore().getEndScore();
325                 i++;
326             }
327         }
328         return (int) Math.floor(sum/i);
329     }
330 
331     public int getTotalAvg(List<SelectCourse> selectCourses) {
332         double sum = 0;
333         int i = 0;
334         for(SelectCourse selectCourse: selectCourses){
335             if(selectCourse.getCourse().getName().equals(this.name)){
336                 sum+= selectCourse.getScore().getTotalScore();
337                 i++;
338             }
339         }
340         this.total = (int) Math.floor(sum/i);
341         return (int) Math.floor(sum/i);
342     }
343 
344     public static Course getCourseByName(List<Course> courses, String name){
345         for(Course c : courses){
346             if(c.getName().equals(name)){
347                 return c;
348             }
349         }
350         return null;
351     }
352 
353     @Override
354     public boolean equals(Object obj) {
355         if (this == obj)
356             return true;
357         if (obj == null || getClass() != obj.getClass())
358             return false;
359         Course course = (Course) obj;
360         return Objects.equals(name, course.name);
361     }
362 
363     @Override
364     public int hashCode() {
365         return Objects.hash(name);
366     }
367 
368     @Override
369     public int compareTo(Course o) {
370         return this.total-o.total;
371     }
372 }
373 
374 abstract class Score {
375     private String stu_id;
376     private String stu_name;
377     private int totalScore = 0;
378     private int dailyScore = 0;
379     private int endScore = 0;
380     private List<SelectCourse> selectCourses;
381 
382     public Score(int totalScore) {
383         this.endScore = totalScore;
384         this.totalScore = totalScore;
385     }
386 
387     public Score(int dailyScore, int endScore) {
388         this.dailyScore = dailyScore;
389         this.endScore = endScore;
390     }
391 
392     public int getEndScore() {
393         return endScore;
394     }
395 
396     public void setEndScore(int endScore) {
397         this.endScore = endScore;
398     }
399 
400     public int getDailyScore() {
401         return dailyScore;
402     }
403 
404     public void setDailyScore(int dailyScore) {
405         this.dailyScore = dailyScore;
406     }
407 
408     public String getStu_id() {
409         return stu_id;
410     }
411 
412     public void setStu_id(String stu_id) {
413         this.stu_id = stu_id;
414     }
415 
416     public String getStu_name() {
417         return stu_name;
418     }
419 
420     public void setStu_name(String stu_name) {
421         this.stu_name = stu_name;
422     }
423 
424     public int getTotalScore() {
425         return totalScore;
426     }
427 
428     public void setTotalScore(int totalScore) {
429         this.totalScore = totalScore;
430     }
431 }
432 
433 class ExScore extends Score {
434     public ExScore(int score1,int score2) {
435         super(score1, score2);
436         this.setTotalScore((int) (score1*0.3+score2*0.7));
437     }
438 }
439 
440 class InScore extends Score {
441     public InScore(int totalScore) {
442         super(totalScore);
443     }
444 }
445 
446 class SelectCourse {
447     private Course course;
448     private Student student;
449     private Score score;
450 
451     public SelectCourse(Course course, Student student, Score score) {
452         this.course = course;
453         this.student = student;
454         this.score = score;
455     }
456 
457     public Course getCourse() {
458         return course;
459     }
460 
461     public void setCourse(Course course) {
462         this.course = course;
463     }
464 
465     public Student getStudent() {
466         return student;
467     }
468 
469     public void setStudent(Student student) {
470         this.student = student;
471     }
472 
473     public Score getScore() {
474         return score;
475     }
476 
477     public void setScore(Score score) {
478         this.score = score;
479     }
480 
481     @Override
482     public boolean equals(Object obj) {
483         if (this == obj)
484             return true;
485         if (obj == null || getClass() != obj.getClass())
486             return false;
487         SelectCourse selectCourse = (SelectCourse) obj;
488         return Objects.equals(student.getStu_id(), selectCourse.student.getStu_id()) && Objects.equals(course.getName(), selectCourse.course.getName()) && Objects.equals(score.getTotalScore(), selectCourse.score.getTotalScore());
489     }
490     @Override
491     public int hashCode() {
492         return Objects.hash(student,course,score);
493     }
494 }
495 
496 class Student implements Comparable<Student> {
497     private String stu_id;
498     private String name;
499     private Clazz cla;
500 
501     public Student(String stu_id, String name) {
502         this.stu_id = stu_id;
503         this.name = name;
504         this.cla = new Clazz(stu_id.substring(0, 6));
505     }
506 
507     public String getStu_id() {
508         return stu_id;
509     }
510 
511     public void setStu_id(String stu_id) {
512         this.stu_id = stu_id;
513     }
514 
515     public String getName() {
516         return name;
517     }
518 
519     public void setName(String name) {
520         this.name = name;
521     }
522 
523     public Clazz getCla() {
524         return cla;
525     }
526 
527     public void setCla(Clazz cla) {
528         this.cla = cla;
529     }
530 
531     public void print(List<SelectCourse> selectCourses){
532         if(selectCourses.isEmpty()){
533             System.out.println(stu_id+" "+name+" did not take any exams");
534         }else{
535             System.out.println(stu_id+" "+name+" "+getAvgGrade(selectCourses));
536         }
537     }
538 
539     public int getAvgGrade(List<SelectCourse> selectCourses) {
540         double sum = 0;
541         int i = 0;
542         for(SelectCourse selectCourse: selectCourses){
543             if(selectCourse.getStudent().getStu_id().equals(this.stu_id)){
544                 sum+= selectCourse.getScore().getTotalScore();
545                 i++;
546             }
547         }
548         return (int) Math.floor(sum/i);
549     }
550 
551     @Override
552     public boolean equals(Object obj) {
553         if (this == obj)
554             return true;
555         if (obj == null || getClass() != obj.getClass())
556             return false;
557         Student student = (Student) obj;
558         return Objects.equals(stu_id, student.stu_id);
559     }
560 
561     @Override
562     public int hashCode() {
563         return Objects.hash(stu_id);
564     }
565 
566     @Override
567     public int compareTo(Student o) {
568         return this.stu_id.compareTo(o.stu_id);
569     }
570 }

测试点

 好像就是关于计算成绩出错的问题导致测试点过不去，但是一直找不到问题所在，下面是该类图：

 

7-2 统计java程序中关键词的出现次数

作者 段喜龙 单位 南昌航空大学

编写程序统计一个输入的Java源码中关键字（区分大小写）出现的次数。说明如下：

• Java中共有53个关键字（自行百度）
• 从键盘输入一段源码，统计这段源码中出现的关键字的数量
• 注释中出现的关键字不用统计
• 字符串中出现的关键字不用统计
• 统计出的关键字及数量按照关键字升序进行排序输出
• 未输入源码则认为输入非法

输入格式:

输入Java源码字符串，可以一行或多行，以exit行作为结束标志

输出格式:

• 当未输入源码时，程序输出Wrong Format
• 当没有统计数据时，输出为空
• 当有统计数据时，关键字按照升序排列，每行输出一个关键字及数量，格式为数量\t关键字

输入样例:

在这里给出一组输入。例如：

//Test public method
public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }
    public HashMap(int initialCapacity, float loadFactor) {
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " +
                                               initialCapacity);
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " +
                                               loadFactor);
        this.loadFactor = loadFactor;
        this.threshold = tableSizeFor(initialCapacity);
    }
exit

 

输出样例:

在这里给出相应的输出。例如：

1	float
3	if
2	int
2	new
2	public
3	this
2	throw

  代码长度限制 16 KB 时间限制 400 ms 内存限制 64 MB   这题很奇怪，看着很简单很容易，但是不知道为什么测试点总是有一个过不去，按照测试点去改了也没有用，总之，很怪！ 接下来是代码：

 1 import java.util.*;
 2 import java.util.regex.Pattern;
 3 import java.util.regex.Matcher;
 4 
 5 public class Main{
 6     public static void main(String[] args) {
 7         Scanner in = new Scanner(System.in);
 8         String[] array = {"abstract","assert","boolean","break","byte","case",
 9                 "catch","char","class","const","continue","default","do","double",
10                 "else","enum","extends","false","final","finally","float","for","goto",
11                 "if","implements","import","instanceof","int","interface","long",
12                 "native","new","null","package","private","protected","public",
13                 "return","short","static","strictfp","super","switch","synchronized",
14                 "this","throw","throws","transient","true","try","void","volatile",
15                 "while"};
16         Set<String> keyword = new TreeSet<>(Arrays.asList(array));
17 
18         Map<String,Integer> map = new HashMap<>();
19         StringBuilder input = new StringBuilder();//将源码存进去
20         for(int i = 1;;i++) {
21             String str = in.nextLine();
22             if(str.equals("exit")) {
23                 break;
24             }
25             input.append(str + "\n");
26         }
27 
28         if(input.toString().isEmpty()) {
29             System.out.println("Wrong Format");
30             System.exit(0);
31         }
32 
33         //删除源码的注释和字符串
34         String newinput = " " + input.toString();
35         newinput = newinput.replaceAll("\"(.*?)\"", " ");
36         newinput = newinput.replaceAll("//.*?\n", " ");
37         newinput = newinput.replaceAll("(/\\*)(\n*.*?)*(\\*/)", " ");
38         //删除源码中的除字母数字的字符
39        // newinput = newinput.replaceAll("[^A-Za-z\\d]", " ");
40 
41         for(String str : keyword){
42             int n = 0;
43             Pattern r = Pattern.compile("[^a-zA-Z\\d]" + str + "[^a-zA-Z\\d]");
44             Matcher m = r.matcher(newinput);
45             while(m.find()) {
46                 n++;
47             }
48             map.put(str,n);
49             if(n > 0) {
50                 System.out.println(map.get(str) + "\t" + str);
51             }
52         }
53     }
54 }

这道题比较容易就不给类图了，下面是没过的测试点：

 7-3 容器-HashMap-检索

作者 蔡轲 单位 南昌航空大学

输入多个学生的成绩信息，包括：学号、姓名、成绩。

学号是每个学生的唯一识别号，互不相同。

姓名可能会存在重复。

使用HashMap存储学生信息，并实现根据学号的检索功能

输入格式:

输入多个学生的成绩信息，每个学生的成绩信息格式：学号+英文空格+姓名+英文空格+成绩

以“end”为输入结束标志

end之后输入某个学号，执行程序输出该生的详细信息

输出格式:

输出查询到的学生信息格式：学号+英文空格+姓名+英文空格+成绩

如果没有查询到，则输出："The student "+查询的学号+" does not exist"

输入样例1:

在这里给出一组输入。例如：

20201107 张少军 83
20201116 李四 78
20201118 郑觉先 80
end
20201116

 

输出样例1:

在这里给出相应的输出。例如：

20201116 李四 78

 

 

输入样例2:

在这里给出一组输入。例如：

20201107 张少军 83
20201116 李四 78
20201118 郑觉先 80
end
20202316

 

输出样例2:

在这里给出相应的输出。例如：

The student 20202316 does not exist

这道题挺简单的就不做多讲解，下面是代码：

 1 // package Ptaoop10;
 2 
 3 import java.util.*;
 4 
 5 public class Main {
 6     public static void main(String[] args) {
 7         // 定义存储学生信息的 HashMap
 8         Map<Integer, Student> studentMap = new HashMap<>();
 9         // 输入学生信息
10         Scanner scanner = new Scanner(System.in);
11         while (true) {
12             String input = scanner.nextLine();
13 
14             if (input.equalsIgnoreCase("end")) {  // 以 end 作为输入结束标志
15                 break;
16             }
17 
18             String[] fields = input.split("\\s+");
19             if (fields.length != 3) {  // 判断用户输入的学生信息格式是否正确
20                 System.out.println("Wrong Format");
21                 continue;
22             }
23 
24             try {
25                 int id = Integer.parseInt(fields[0]);
26                 String name = fields[1];
27                 int score = Integer.parseInt(fields[2]);
28 
29                 Student student = new Student(id, name, score);
30                 studentMap.put(id, student);
31             } catch (NumberFormatException e) {
32                 System.out.println("Wrong Format");
33             }
34         }
35         // 根据学号检索学生信息
36         while (true) {
37             String input = scanner.nextLine();
38             if (input.equalsIgnoreCase("end")) { // 以 end 作为查询结束标志
39                 break;
40             }
41 
42             try {
43                 int id = Integer.parseInt(input);
44                 Student student = studentMap.get(id);
45                 if (student != null) {
46                     System.out.println(student);
47                 } else {
48                     System.out.println("The student "+id+" does not exist");
49                 }
50             } catch (NumberFormatException e) {
51                 System.out.println("Wrong Format");
52             }
53             return;
54         }
55     }
56 }
57 
58 class Student {
59     private int id;
60     private String name;
61     private int score;
62 
63     public Student(int id, String name, int score) {
64         this.id = id;
65         this.name = name;
66         this.score = score;
67     }
68 
69     public int getId() {
70         return id;
71     }
72 
73     public String getName() {
74         return name;
75     }
76 
77     public double getScore() {
78         return score;
79     }
80 
81     @Override
82     public String toString() {
83         return id + " "+name+" "+score;
84     }
85 }

 

7-4 容器-HashMap-排序

作者 蔡轲 单位 南昌航空大学

输入多个学生的成绩信息，包括：学号、姓名、成绩。

学号是每个学生的唯一识别号，互不相同。

姓名可能会存在重复。

要求：使用HashMap存储学生信息。

输入格式:

输入多个学生的成绩信息，每个学生的成绩信息格式：学号+英文空格+姓名+英文空格+成绩

以“end”为输入结束标志

输出格式:

按学号从大到小的顺序输出所有学生信息，每个学生信息的输出格式：学号+英文空格+姓名+英文空格+成绩

输入样例:

在这里给出一组输入。例如：

20201124 张少军 83
20201136 李四 78
20201118 郑觉先 80
end

 

输出样例:

在这里给出相应的输出。例如：

20201136 李四 78
20201124 张少军 83
20201118 郑觉先 80

这题也是类似，下面代码：

 1 // package pta101;
 2 
 3 import java.util.*;
 4 
 5 public class Main {
 6     public static void main(String[] args) {
 7         // 定义存储学生信息的 HashMap
 8         Map<Integer, Student> studentMap = new HashMap<>();
 9 
10         // 输入学生信息
11         Scanner scanner = new Scanner(System.in);
12         while (true) {
13             String input = scanner.nextLine();
14 
15             if (input.equalsIgnoreCase("end")) {  // 以 end 作为输入结束标志
16                 break;
17             }
18 
19             String[] fields = input.split("\\s+");
20             if (fields.length != 3) {  // 判断用户输入的学生信息格式是否正确
21                 System.out.println("Wrong Format");
22                 continue;
23             }
24 
25             try {
26                 int id = Integer.parseInt(fields[0]);
27                 String name = fields[1];
28                 int score = Integer.parseInt(fields[2]);
29 
30                 Student student = new Student(id, name, score);
31                 studentMap.put(id, student);
32             } catch (NumberFormatException e) {
33                 System.out.println("Wrong Format");
34             }
35         }
36 
37         // 根据学号排序并输出学生信息
38         List<Integer> keyList = new ArrayList<>(studentMap.keySet());
39         Collections.sort(keyList); //升序
40         Collections.reverse(keyList); // 升序进行翻转
41 
42         for (Integer id : keyList) {
43             System.out.println(studentMap.get(id));
44         }
45         return;
46     }
47 }
48 
49 class Student {
50     private int id;
51     private String name;
52     private int score;
53 
54     public Student(int id, String name, int score) {
55         this.id = id;
56         this.name = name;
57         this.score = score;
58     }
59 
60     public int getId() {
61         return id;
62     }
63 
64     public String getName() {
65         return name;
66     }
67 
68     public int getScore() {
69         return score;
70     }
71 
72     @Override
73     public String toString() {
74         return id + " "+name+" "+score;
75     }
76 }

 

7-5 课程成绩统计程序-2

课程成绩统计程序-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）成绩平均分只取整数部分，小数部分丢弃

参考类图（与第一次相同，其余内容自行补充）

 

又是这题目，和菜单程序一样迭代到2了，虽然做了那么多次了还是出现种种问题，先展示一下没过的测试点：

 总共有四个测试点没有通过，分数满分60分也只有44分，太奇怪了还是和第一次一样反正只要是和学生成绩有关的测试点就总是出现各种问题，调试了半天仍然出现问题，只能说在以后得更加注重细节！

类图和第一次差不了多少，类图如下：

 

7-6 动物发声模拟器（多态）

作者 刘凤良 单位 天津仁爱学院

设计一个动物发生模拟器，用于模拟不同动物的叫声。比如狮吼、虎啸、狗旺旺、猫喵喵……。
定义抽象类Animal，包含两个抽象方法：获取动物类别getAnimalClass()、动物叫shout()；
然后基于抽象类Animal定义狗类Dog、猫类Cat和山羊Goat，用getAnimalClass()方法返回不同的动物类别（比如猫，狗，山羊），用shout()方法分别输出不同的叫声（比如喵喵、汪汪、咩咩）。
最后编写AnimalShoutTest类测试，输出：
猫的叫声：喵喵
狗的叫声：汪汪
山羊的叫声：咩咩

其中，在AnimalShoutTestMain类中，用speak(Animal animal){}方法输出动物animal的叫声，在main()方法中调用speak()方法，分别输出猫、狗和山羊对象的叫声。

请在下面的【】处添加代码。

 

//动物发生模拟器.  请在下面的【】处添加代码。
public class AnimalShoutTest2 {
    public static void main(String[] args) {        
         Cat cat = new Cat();
         Dog dog = new Dog();        
        Goat goat = new Goat();
         speak(cat);
         speak(dog);
         speak(goat);
    }
    //定义静态方法speak()
    【】

}

//定义抽象类Animal
【】class Animal{
    【】
}
//基于Animal类，定义猫类Cat，并重写两个抽象方法
class Cat 【】{
    【】    
    【】
}
//基于Animal类，定义狗类Dog，并重写两个抽象方法
class Dog 【】{
    【】
    【】
}
//基于Animal类，定义山羊类Goat，并重写两个抽象方法
class Goat 【】{
    【】
    【】
}

 

输入样例:

 

输出样例:

猫的叫声：喵喵
狗的叫声：汪汪
山羊的叫声：咩咩

这题可就太简单了，下面是代码：

 1 // package Ptaoop10;
 2 
 3 //动物发生模拟器.  请在下面的【】处添加代码。
 4 public class Main {
 5     public static void main(String[] args) {
 6         Cat cat = new Cat();
 7         Dog dog = new Dog();
 8         Goat goat = new Goat();
 9         speak(cat);
10         speak(dog);
11         speak(goat);
12     }
13     // 定义静态方法speak()
14 
15     private static void speak(Animal animal) {
16         System.out.println(animal.getAnimalClass() + "的叫声：" + animal.shout());
17     }
18 }
19 
20 //定义抽象类Animal
21 abstract class Animal {
22     abstract public String getAnimalClass();
23     abstract public String shout();
24 }
25 
26 //基于Animal类，定义猫类Cat，并重写两个抽象方法
27 class Cat extends Animal {
28     @Override
29     public String getAnimalClass() {
30         return "猫";
31     }
32     @Override
33     public String shout() {
34         return "喵喵";
35     }
36 }
37 //基于Animal类，定义狗类Dog，并重写两个抽象方法
38 class Dog extends Animal {
39     @Override
40     public String getAnimalClass() {
41         return "狗";
42     }
43 
44     @Override
45     public String shout() {
46         return "汪汪";
47     }
48 }
49 
50 //基于Animal类，定义山羊类Goat，并重写两个抽象方法
51 class Goat extends Animal {
52     @Override
53     public String getAnimalClass() {
54         return "山羊";
55     }
56     @Override
57     public String shout() {
58         return "咩咩";
59     }
60 }

采坑心得

　　在课程成绩程序-1和2里面有太多因为计算能力不够而丢失的测试点，由于在编程过程中没有做好备注导致代码写完测试点没有过去都不知道从哪里找错误，一定要多备注，多测试。

　　对象的创建分析，类与对象的关系

　　类是一种抽象的数据类型，它是对某一事物的整体描述/定义，但是并不能代表一个具体的事物
　　动物、植物、手机、电脑…
　　Person类、Pet类、Car类，这些类都是用来描述/定义某一类具体的事物应该具备的特点和行为
　　对象是抽象概念具体的实例

　　张三就是一个人的具体实例，张三家里的旺财就是狗的一个具体实例
　　能够体现出特点，展现出功能的是具体的实例，而不是一个抽象的概念
　　创建与初始化对象

　　使用new关键字创建对象
　　使用new关键字创建的时候，除了分配内存空间之外还会给创建好的对象默认初始化以及对类中构造器的调用
　　类中的构造器也称为构造方法，是在进行对象创建的时候必须要调用的，并且构造器有以下两个特点：
　　必须和类的名字相同
　　必须没有返回类型，也不能使用void

　　静态代码块、构造代码块、局部代码块
　　静态代码块
　　随着类的加载而加载，并且只被加载一次，一般用于项目的初始化

1 static{...}

概述
1、 静态代码块：在类加载时就加载，并且只被加载一次，一般用于项目的初始化

2、 构造代码块：在调用构造方法前会自动调用，每次创建对象都会被调用

3、 局部代码块：方法里的代码块，方法被调用时才会执行

4、 静态代码块：static{ }，位置：在类里方法外

5、 TODO创建测试类，类中写好静态代码块，构造代码块，构造方法，普通方法里嵌套局部代码块。测试他们的执行顺序。

6、 静态 - 构造代码块 - 构造方法 - 局部

比较值相等最好用equal别用==

 

 1 public class equalTest {
 2 public static void main(String[] args) {
 3 Integer a = 12;
 4 Integer b = 12;
 5 Integer c = 133;
 6 Integer d = 133;
 7 Integer e = 24;
 8 int f = 133;
 9 
10 System.out.println(a == b); //true
11 System.out.println(c == d); //false
12 System.out.println(f == c); //true
13 System.out.println(a + b == e); //true
14 }

 通过这次学会了Javafx的使用，实话说，感觉这里蛮难的，里面好多方法的使用都要去学习，去琢磨，通过查阅资料，浏览他人优质的代码去学习，去改进，整个实验进行的很曲折，功能也有些不完善，但是总体而言还是收获很大的，javafx里面的按钮事件驱动机制、lambda表达式等等，还有很多值得去学习。

改进建议

 　　Java编程中因首先针对抽象类及接口对项目搭建宏观整体框架。在通过对父类继承或对接口实现来填充程序内容已完善细节。对于整体框架的建立至关重要，关系到之后对细节实现的难易程度以及整体的可复用性。良好的框架使得代码的可复用性提高，同时对代码增加细节也将方便进行。因此在编写程序之前，因首先分析整体的执行顺序并对其中的复杂动作进行相应化简使得代码更易书写。

总结

　　在学习Java的过程中我得出这样的结论：

在学习Java的面向对象的编程语言的特性。比如继承，构造器，抽象类，接口，方法的多态，重载，覆盖，Java的异常处理机制。对于一个没有面向对象语言背景的人来说，我觉得这个过程需要花很长很长时间，因为学习Java之前没有C++的经验，只有C语言的经验，花了很长时间，才彻底把这些　　　　　　概念都搞清楚，把书上面的例子反复的揣摩，修改，尝试，把那几章内容反复的看过来，看过去，看了很多遍，才彻底领悟了。学习中，要养成良好的习惯（写括号时要成对，字母大小写要区分，单词拼写要准确）。在学习的过程中，最好不是仅仅停留在java表层，不是抄书上的例子运行出结果就可以。要注意，即便对一个简单的例子也要有耐心去琢磨、调试、改动。在学习的过程中一定要动手做、试着写代码，而不是抱一本书看看就行。很多东西和体会必须自己动手才能真正属于自己。 在 Java 的学习过程中，可能会遇到形形色色的问题不容易解决，应多去专业论坛了解相关的知识，书本上的知识有限。要会从网上搜索有用的信息 加以整理，促进学习的深入和知识水平的提高。

　　最后，对于这次面向对象编程的课程我觉得很有赞扬的地方，首先从pta平台布置多种不同类型的题目，全是任课老师自己设计的题目，更贴近学生的需求和掌握，属实暖心，上课也很生动，很容易让学生产生兴趣，很满意！

标签：return,String,int,public,JavaBlog,id,name
From： https://www.cnblogs.com/fzq2513610927/p/17510105.html