标签：String int 博客 name course 课程 OOP new 第三次

一、前言

这是本学期的最后一次博客，也是最后一次作业。但是由于前期打的基础不够扎实以及畏难的心理，PTA中的难题我大都没有解决，只通过了一些比较简单的测试点。虽然题量很大，但并不全是难得无法动手的，下面我会选取其中的一些题目进行分析。这些题目涉及的知识面也很广，老师上课讲到的没讲到的都有用到，基本贯穿了所有的知识点。面对复杂的题目，通过类图下手确实是一个很棒的方法。

二、设计与分析

OOP08

只有一题，就是课程成绩统计程序-1 这一题。之前的菜单题，前面写的不认真导致我后面想要写迭代太过吃力，所以这次的成绩系统我在 -1 就很认真的写，无奈最后只拿到了37分。

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

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

参考类图：

输入样例1:

仅有课程。例如：

java 必修 考试
数据结构 选修 考试
形式与政治 选修 考察
end

输出样例1:

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

java has no grades yet
数据结构 has no grades yet
形式与政治 has no grades yet

输入样例2:

单门考试课程单个学生。例如：

java 必修 考试
20201103 张三 java 20 40
end

输出样例2:

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

20201103 张三 34
java 20 40 34
202011 34

输入样例3:

单门考察课程单个学生。例如：

java 选修 考察
20201103 张三 java 40
end

输出样例3:

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

20201103 张三 40
java 40 40
202011 40

输入样例4:

考试课程单个学生不匹配的考核方式。例如：

java 必修 考试
20201103 张三 java 20
end

输出样例4:

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

20201103 张三 : access mode mismatch
20201103 张三 did not take any exams
java has no grades yet
202011 has no grades yet

输入样例5:

单门课程，单个学生，课程类型与考核类型不匹配。例如：

java 必修 考察
20201103 张三 java 40
end

输出样例5:

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

java : course type & access mode mismatch
java does not exist
20201103 张三 did not take any exams
202011 has no grades yet

输入样例6:

单门课程，多个学生。例如：

java 选修 考察
20201103 李四 java 60
20201104 王五 java 60
20201101 张三 java 40
end

输出样例6:

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

20201101 张三 40
20201103 李四 60
20201104 王五 60
java 53 53
202011 53

输入样例7:

单门课程，单个学生，课程类型与考核类型不匹配。例如：

形式与政治 必修 考试
数据库 选修 考试
java 选修 考察
数据结构 选修 考察
20201103 李四 数据结构 70
20201103 李四 形式与政治 80 90
20201103 李四 java 60
20201103 李四 数据库 70 78
end

输出样例7:

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

20201103 李四 73
java 60 60
数据结构 70 70
数据库 70 78 75
形式与政治 80 90 87
202011 73

输入样例8:

单门课程，单个学生，成绩越界。例如：

数据结构 选修 考察
20201103 李四 数据结构 101
end

输出样例8:

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

wrong format
数据结构 has no grades yet

输入样例9:

多门课程，多个学生，多个成绩。例如：

形式与政治 必修 考试
数据库 选修 考试
java 选修 考察
数据结构 选修 考察
20201205 李四 数据结构 70
20201103 李四 形式与政治 80 90
20201102 王五 java 60
20201211 张三 数据库 70 78
end

输出样例9:

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

20201102 王五 60
20201103 李四 87
20201205 李四 70
20201211 张三 75
java 60 60
数据结构 70 70
数据库 70 78 75
形式与政治 80 90 87
202011 73
202012 72

源码如下：

  1 import java.util.*;
  2 public class Main{
  3 
  4     static class Course {
  5         String name;
  6         String nature;
  7         String assessmentMethod;
  8 
  9         public Course(String name, String nature, String assessmentMethod) {
 10             this.name = name;
 11             this.nature = nature;
 12             this.assessmentMethod = assessmentMethod;
 13         }
 14     }
 15 
 16     static class Grade {
 17         String studentNumber;
 18         String name;
 19         String courseName;
 20         int regularGrade;
 21         int finalGrade;
 22 
 23         public Grade(String studentNumber, String name, String courseName, int regularGrade, int finalGrade) {
 24             this.studentNumber = studentNumber;
 25             this.name = name;
 26             this.courseName = courseName;
 27             this.regularGrade = regularGrade;
 28             this.finalGrade = finalGrade;
 29         }
 30     }
 31 
 32     public static void main(String[] args) {
 33         Scanner scanner = new Scanner(System.in);
 34         List<Course> courses = new ArrayList<>();
 35         List<Grade> grades = new ArrayList<>();
 36 
 37         while (true) {
 38             String line = scanner.nextLine();
 39             if ("end".equals(line)) {
 40                 break;
 41             }
 42             String[] info = line.split(" ");
 43 
 44             // 读取课程信息
 45             if (info.length == 3) {
 46                 String courseName = info[0];
 47                 String nature = info[1];
 48                 String assessmentMethod = info[2];
 49                 courses.add(new Course(courseName, nature, assessmentMethod));
 50             }else if(info.length == 2 && "必修".equals(info[1])){
 51                 //如果性质是必修课，考核方式可以没有
 52                 String courseName = info[0];
 53                 String nature = info[1];
 54                 courses.add(new Course(courseName, nature, null));
 55             }
 56 
 57             // 读取班级信息
 58             if(info.length == 5){
 59                 String studentNumber = info[0];
 60                 String name = info[1];
 61                 String courseName = info[2];
 62                 int regularGrade = Integer.parseInt(info[3]);
 63                 int finalGrade = Integer.parseInt(info[4]);
 64                 grades.add(new Grade(studentNumber, name, courseName, regularGrade, finalGrade));
 65             }
 66 
 67             //未输入平时成绩
 68             if(info.length == 4){
 69                 String studentNumber = info[0];
 70                 String name = info[1];
 71                 String courseName = info[2];
 72                 int finalGrade = Integer.parseInt(info[3]);
 73                 grades.add(new Grade(studentNumber, name, courseName, -1, finalGrade));
 74             }
 75         }
 76 
 77         //判断成绩越界
 78         for (Grade value : grades) {
 79             if (value.regularGrade > 100 || value.finalGrade > 100) {
 80                 System.out.println("wrong format");
 81                 for (Course cours : courses) {
 82                     System.out.println(cours.name + " has no grades yet");
 83                 }
 84                 return;
 85             }
 86         }
 87 
 88         // 计算每个学生的总成绩平均分
 89         Map<String, Integer> studentTotalGradeSum = new HashMap<>();
 90         Map<String, Integer> studentTotalGradeCount = new HashMap<>();
 91         Map<String, Integer> courseRegularGradeSum = new HashMap<>();
 92         Map<String, Integer> courseRegularGradeCount = new HashMap<>();
 93         Map<String, Integer> courseFinalGradeSum = new HashMap<>();
 94         Map<String, Integer> courseFinalGradeCount = new HashMap<>();
 95         Map<String, Integer> courseTotalGradeSum = new HashMap<>();
 96         Map<String, Integer> courseTotalGradeCount = new HashMap<>();
 97 
 98         // 计算一个班级所有课程的总成绩平均分
 99         Map<String, Integer> classTotalGradeSum = new HashMap<>();
100         Map<String, Integer> classTotalGradeCount = new HashMap<>();
101         for (Grade grade : grades) {
102             if (isValidCourse(grade, courses)) {
103                 break;
104             }
105 
106             Course course = getCourse(grade, courses);
107             if (isValidGrade(course, grade)) {
108                 break;
109             }
110 
111             if (grade.regularGrade != -1) {
112                 courseRegularGradeSum.put(course.name, courseRegularGradeSum.getOrDefault(course.name, 0) + grade.regularGrade);
113                 courseRegularGradeCount.put(course.name, courseRegularGradeCount.getOrDefault(course.name, 0) + 1);
114             }
115 
116             courseFinalGradeSum.put(course.name, courseFinalGradeSum.getOrDefault(course.name, 0) + grade.finalGrade);
117             courseFinalGradeCount.put(course.name, courseFinalGradeCount.getOrDefault(course.name, 0) + 1);
118 
119             int totalGrade = ("考察".equals(course.assessmentMethod)) ? grade.finalGrade : calculateTotalGrade(grade.regularGrade, grade.finalGrade);
120 
121             courseTotalGradeSum.put(course.name, courseTotalGradeSum.getOrDefault(course.name, 0) + totalGrade);
122             courseTotalGradeCount.put(course.name, courseTotalGradeCount.getOrDefault(course.name, 0) + 1);
123 
124             studentTotalGradeSum.put(grade.studentNumber, studentTotalGradeSum.getOrDefault(grade.studentNumber, 0) + totalGrade);
125             studentTotalGradeCount.put(grade.studentNumber, studentTotalGradeCount.getOrDefault(grade.studentNumber, 0) + 1);
126 
127             String className = grade.studentNumber.substring(0, 6);
128             classTotalGradeSum.put(className, classTotalGradeSum.getOrDefault(className, 0) + totalGrade);
129             classTotalGradeCount.put(className, classTotalGradeCount.getOrDefault(className, 0) + 1);
130         }
131 
132         // Sort and print average score of total grade for each student
133         List<String> studentAverages = new ArrayList<>();
134         for (Grade grade : grades) {
135             String studentNumber = grade.studentNumber;
136             String name = grade.name;
137             int totalGradeSum = studentTotalGradeSum.getOrDefault(studentNumber, 0);
138             int totalGradeCount = studentTotalGradeCount.getOrDefault(studentNumber, 0);
139             if (totalGradeCount == 0) {
140                 studentAverages.add(studentNumber + " " + name + " did not take any exams");
141             } else {
142                 int average = totalGradeSum / totalGradeCount;
143                 studentAverages.add(studentNumber + " " + name + " " + average);
144             }
145         }
146 
147         // 排序
148         studentAverages.sort(Comparator.comparing(s -> s.split(" ")[0]));
149 
150         // 元素去重
151         List<String> noRepeatArr = new ArrayList<>();
152         for (String average : studentAverages) {
153             if(!noRepeatArr.contains(average)){
154                 noRepeatArr.add(average);
155             }
156         }
157 
158         for (String average : noRepeatArr) {
159             System.out.println(average);
160         }
161 
162         // 打印单门课程的平均分
163         List<String> temp = new ArrayList<>();
164         for (Course course : courses) {
165             String courseName = course.name;
166             int regularGradeCount = courseRegularGradeCount.getOrDefault(courseName, 0);
167             int regularGradeSum = courseRegularGradeSum.getOrDefault(courseName, 0);
168             int finalGradeSum = courseFinalGradeSum.getOrDefault(courseName, 0);
169             int finalGradeCount = courseFinalGradeCount.getOrDefault(courseName, 0);
170             int totalGradeSum = courseTotalGradeSum.getOrDefault(courseName, 0);
171             int totalGradeCount = courseTotalGradeCount.getOrDefault(courseName, 0);
172 
173 
174             if (regularGradeCount == 0 && finalGradeCount == 0 && totalGradeCount == 0) {
175                 System.out.println(courseName + " has no grades yet");
176             } else {
177                 int regularAverage = (regularGradeCount != 0) ? regularGradeSum / regularGradeCount : -1;
178                 int finalAverage = (finalGradeCount != 0) ? finalGradeSum / finalGradeCount : -1;
179                 int totalAverage = (totalGradeCount != 0) ? totalGradeSum / totalGradeCount : -1;
180 
181                 if(regularAverage == -1){
182                     temp.add(courseName + " " + finalAverage + " " + "-1" + " " + totalAverage);
183                 }else{
184                     temp.add(courseName + " " + regularAverage + " " + finalAverage + " " + totalAverage);
185                 }
186 
187             }
188         }
189 
190         // 排序输出
191         temp.sort(Comparator.comparing(s -> s.split(" ")[3]));
192         for (String s:temp
193              ) {
194             if("-1".equals(s.split(" ")[2])){
195                 s = s.replace("-1 ","");
196                 System.out.println(s);
197             }else {
198                 System.out.println(s);
199             }
200         }
201 
202         // 排序并打印一个班级中所有课程的总学分的平均分
203         List<String> classAverages = new ArrayList<>();
204         for (String className : classTotalGradeSum.keySet()) {
205             int totalGradeSum = classTotalGradeSum.getOrDefault(className, 0);
206             int totalGradeCount = classTotalGradeCount.getOrDefault(className, 0);
207             if (totalGradeCount == 0) {
208                 classAverages.add(className + " has no grades yet");
209             } else {
210                 int average = totalGradeSum / totalGradeCount;
211                 classAverages.add(className + " " + average);
212             }
213         }
214 
215         classAverages.sort(Comparator.comparing(s -> s.split(" ")[0]));
216         for (String average : classAverages) {
217             System.out.println(average);
218         }
219     }
220 
221     private static boolean isValidCourse(Grade grade, List<Course> courses) {
222         //如果解析某个课程信息时，输入的课程性质和课程的考核方式不匹配，输出：课程名称+" : course type & access mode mismatch"
223         for (Course course : courses) {
224 
225             //必修课的考核方式必须为考试
226             if ("必修".equals(course.nature) && !"考试".equals(course.assessmentMethod)) {
227                 System.out.println(course.name + " : course type & access mode mismatch");
228                 return true;
229             }
230 
231             if (course.name.equals(grade.courseName)) {
232                 return false;
233             }
234 
235             //选修课可以选择考试、考察任一考核方式
236             if ("选修".equals(course.nature) && !"考察".equals(course.assessmentMethod) && !"考试".equals(course.assessmentMethod)) {
237                 System.out.println(course.name + " : course type & access mode mismatch");
238                 return true;
239             }
240 
241         }
242         //如果解析某个成绩信息时，课程名称不在已输入的课程列表中，输出：学号+英文空格+姓名+英文空格+":"+课程名称+英文空格+"does not exist"
243         System.out.println(grade.studentNumber + " " + grade.name + " :" + grade.courseName + " does not exist");
244         return true;
245     }
246 
247     private static Course getCourse(Grade grade, List<Course> courses) {
248         for (Course course : courses) {
249             if (course.name.equals(grade.courseName)) {
250                 return course;
251             }
252         }
253         return null;
254     }
255 
256     private static boolean isValidGrade(Course course, Grade grade) {
257         if (course == null || grade == null) {
258             return true;
259         }
260 
261         //如果解析某个成绩信息时，输入的成绩数量和课程的考核方式不匹配，输出：学号+英文空格+姓名+英文空格+": access mode mismatch"
262         if (grade.regularGrade == -1 && "考试".equals(course.assessmentMethod)) {
263             System.out.println(grade.studentNumber + " " + grade.name + " : access mode mismatch");
264             return true;
265         }
266 
267         return false;
268     }
269 
270     private static int calculateTotalGrade(int regularGrade, int finalGrade) {
271         //平时成绩权重0.3，期末成绩权重0.7，总成绩=平时成绩*0.3+期末成绩*0.7
272         return (int) (regularGrade * 0.3 + finalGrade * 0.7);
273     }
274 }

类图如下：

看了类图才知道我当时写的时候整体框架就不符合题目要求，在之前写菜单的时候就意识到了类图的重要性，结果在这里又忘了，还是在题目给了类图的情况下（被自己蠢到...）。

如果在当时我用了power designer我绝对不可能继续这样写的，也许就能对的更多了。

OOP09

也仅有一题，统计Java程序中关键词的出现次数。这一题是段老师当时在上课讲到Map和Set的时候，布置给我们的，要求要用到我们用Set和Map来解决，感觉也是很有意思的一道题。

我对这道题的认知思路是：好像有点难（刚看）—— 也不是很难，有点思路（了解了HashSet和HashMap的逻辑用法）—— 有点难啊（试图解决问题一段时间）

听段老师说这道题的代码越短越好，五十行以内才算写的不错。（汗颜）

编写程序统计一个输入的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

源码如下：

 1 import java.util.*;
 2 import java.util.regex.Matcher;
 3 import java.util.regex.Pattern;
 4 
 5 public class Main {
 6     public static void main(String[] args) {
 7         Scanner input = new Scanner(System.in);
 8         StringBuilder ss = new StringBuilder();
 9         Map<String, Integer> map = new HashMap<>();
10         String[] key = {"abstract", "assert", "boolean", "break", "byte", "case", "catch",
11                 "char", "class", "const", "continue", "default", "do", "double", "else",
12                 "enum", "extends", "false", "final", "finally", "float",
13                 "for", "goto", "if", "implements", "import", "instanceof", "int", "interface", "long", "native", "new", "null",
14                 "package", "private", "protected", "public", "return", "short", "static", "strictfp", "super",
15                 "switch", "synchronized", "this", "throw", "throws", "transient", "true", "try", "void", "volatile", "while"};
16         Set<String> keywords = new HashSet<>(Arrays.asList(key));
17         for (int i = 0; ; i++) {
18             String a = input.nextLine();
19             if (a.equals("exit"))
20                 break;
21             if (a.matches("(.*)//(.*)")) {
22                 String b[] = a.split("//");
23                 ss.append(b[0]).append(" ");
24             } else {
25                 ss.append(a).append(" ");
26             }
27         }
28         String s = ss.toString();
29         Pattern p = Pattern.compile("\"(.*?)\"");
30         Matcher m = p.matcher(s);
31         while (m.find()) {
32             s = s.replace(m.group(), " ");
33             m = p.matcher(s);
34         }
35         p = Pattern.compile("/\\*(.*?)\\*/", Pattern.DOTALL);
36         m = p.matcher(s);
37         while (m.find()) {
38             s = s.replace(m.group(), " ");
39             m = p.matcher(s);
40         }
41         s = s.replaceAll("[^a-zA-Z]", " ");
42 
43         String[] s1 = s.split(" ");
44         for (String value : s1) {
45             if (keywords.contains(value)) {
46                 map.put(value, map.getOrDefault(value, 0) + 1);
47             }
48         }
49 
50         Set<String> set = map.keySet();
51         List<String> list = new ArrayList<>(set);
52         Collections.sort(list);
53         for (String keyword : list) {
54             System.out.println(map.get(keyword) + "\t" + keyword);
55         }
56     }
57 }

唯一的测试用例是正确的，但有两个测试点未通过，不知道出错在哪..

OOP10 和 OOP11属于是题目比较容易，但是难的菜单迭代也确实很难。
除去菜单迭代，基本考的是Set和Map的使用，以及多态和接口。

以这个考察接口和栈的题目为例：

定义IntegerStack接口，用于声明一个存放Integer元素的栈的常见方法:

public Integer push(Integer item);
//如果item为null，则不入栈直接返回null。如果栈满，也返回null。如果插入成功，返回item。

public Integer pop();   //出栈，如果为空，则返回null。出栈时只移动栈顶指针，相应位置不置为null
public Integer peek();  //获得栈顶元素，如果为空，则返回null.
public boolean empty(); //如果为空返回true
public int size();      //返回栈中元素个数

定义IntegerStack的实现类ArrayIntegerStack，内部使用数组实现。创建时，可指定内部数组大小。

main方法说明

输入n，建立可包含n个元素的ArrayIntegerStack对象
输入m个值，均入栈。每次入栈均打印入栈返回结果。
输出栈顶元素，输出是否为空，输出size
使用Arrays.toString()输出内部数组中的值。
输入x，然后出栈x次，每次出栈均打印。
输出栈顶元素，输出是否为空，输出size
使用Arrays.toString()输出内部数组中的值。

思考

如果IntegerStack接口的实现类内部使用ArrayList来存储元素，怎么实现？测试代码需要进行什么修改？

输入样例

输出样例

1
2
3
3,false,3
[1, 2, 3, null, null]
3
2
1,false,1
[1, 2, 3, null, null]

源码如下：

import java.util.*;
 
interface IntegerStack{
    public Integer push(Integer item);
    public Integer pop();   //出栈，如果为空，则返回null。出栈时只移动栈顶指针，相应位置不置为null
    public Integer peek();  //获得栈顶元素，如果为空，则返回null.
    public boolean empty(); //如果为空返回true
    public int size();      //返回栈中元素个数
}

class ArrayIntegerStack implements IntegerStack{
    private int a[];
    private int end = 0;
 
    public ArrayIntegerStack(int num) {
        a = new int[num];
    }
 
    @Override
    public Integer push(Integer item) {
        if (item == null){
            return null;
        }
        if (end == a.length){
            return null;
        }
        a[end] = item;
        end++;
        return item;
    }
 
    @Override
    public Integer pop() {
        if (end == 0){
            return null;
        }
        end--;
        return a[end];
    }
 
    @Override
    public Integer peek() {
        if (end == 0){
            return null;
        }
        return a[end-1];
    }
 
    @Override
    public boolean empty() {
        if (end == 0){
            return true;
        }
        return false;
    }
 
    @Override
    public int size() {
        return end;
    }
 
    @Override
    public String toString() {
        String s = "";
        int i = 0;
        while (i < end - 1){
            s += a[i] + ", ";
            i++;
        }
        if (end == 0){
            while (i < a.length - 1){
                s += "null, ";
                i++;
            }
            s += "null";
        }else {
            if (end < a.length){
                s += a[i] + ", ";
                for (int p = 0; p < a.length - end - 1; p++){
                    s += "null, ";
                }
                s += null;
            }else {
                s += a[i];
            }
        }
 
        return "["+s+"]";
    }
}
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        ArrayIntegerStack arrayIntegerStack = new ArrayIntegerStack(sc.nextInt());
        int num = sc.nextInt();
        for(int i = 0; i < num; i++){
            System.out.println(arrayIntegerStack.push(sc.nextInt()));
        }
        System.out.println(arrayIntegerStack.peek() + "," + arrayIntegerStack.empty() + "," + arrayIntegerStack.size());
        String arr = arrayIntegerStack.toString();
        System.out.println(arrayIntegerStack.toString());
        int time = sc.nextInt();
        for (int i = 0; i < time; i++){
            System.out.println(arrayIntegerStack.pop());
        }
        System.out.println(arrayIntegerStack.peek() + "," + arrayIntegerStack.empty() + "," + arrayIntegerStack.size());
        System.out.println(arr);
    }
}

三、踩坑心得

老坑踩了也不止一两次了，每次都是在最后才意识到类图的重要性。通过类图来构建整体框架，再敲出这个整体框架，补全框架里的代码，这个才是最省事省力的解决问题的方法。而不是想到一步写一步，这种笨方法会让代码不像一个整体，而且费时费力。再一个就是可以通过测试用例来想象源码的格式（这可能也是应试教育的结果），这能大大提高pta的得分率（并不是面向结果编程）。

四、改进建议

这几次pta作业考察的范围很综合，基本涉及到了学到的所有知识点，加强了我们对知识点的印象。通过这几次题目集我明白了整个代码要分成块，每一个部分应该有它自己的功能。同时也熟悉了两个特殊的类，栈和队列（这很计算机）。同时我也知道了自己在那些方面仍有不足：正则表达式和对符号的处理（关键字那个题目集），这是基础但是又用的非常广泛的知识点，必须牢牢掌握。这次博客总结已经接近尾声，这个学期的Java课也要结束了，但是只是学校的课程结束了，我们的Java学习仍在继续，因为真正需要我们学会的Java思想仍然欠缺。面向对象程序设计是专业的核心课，后续很多课程都是建立在这门课的基础上的，所以我们还需要花更多的时间来学习。

五、总结

对课程学习的总结我想说的在四已经基本说完了，在这里我对对本门课程的教学理念（OBE）、教学方法（边讲边练）、教学组织（线上线下混合式教学）、教学过程（PTA题目集驱动）及教学模式（BOPPPS) 发表一下我的看法：

1.教学理念（OBE）：

OBE是指，教学设计和教学实施的目标是学生通过教育过程最后所取得的学习成果。

　　就我所体会和观察的，成果导向在PTA作业中的体现是：我们抓着测试点不放，以“面向结果”式的编程来完成题目的要求，追求分数上的达标，拿到100分后便如释重负。而质量上就难以得知了，有时候认为自己确实写得不够好不够简洁，但是也很少去想着动手修改，因为已经达标了。

2.边讲边练：

　　编程作为工科，动手是不可避免的。边讲边练能让我们更容易理解知识点，同时增强我们的动手能力。

3.教学过程（PTA题目集驱动）：

　　就编程而言，感觉这是最好的练习办法，但是为了通过测试点可能会面向结果编程。

4.教学模式（BOPPPS)：　

Boppps教学模式是一种以教育目标为导向，以学生为中心的新型教学模式。BOPPP的名称来源于英语单词在教学模式的六个教学环节中的初始组合，包括六个教学环节：课程导入、学习目标、预评估、参与式学习、后评估和总结。

感觉高中的教学方式就是如此，感觉很容易接受。

标签：String,int,博客,name,course,课程,OOP,new,第三次
From： https://www.cnblogs.com/wzryq/p/17510227.html

OOP第三次博客总结

一、前言

二、设计与分析

输入样例1:

输出样例1:

输入样例2:

输出样例2:

输入样例3:

输出样例3:

输入样例4:

输出样例4:

输入样例5:

输出样例5:

输入样例6:

输出样例6:

输入样例7:

输出样例7:

输入样例8:

输出样例8:

输入样例9:

输出样例9:

输入格式:

输出格式:

输入样例:

输出样例:

main方法说明

思考

输入样例

输出样例

三、踩坑心得

四、改进建议

五、总结

对课程学习的总结我想说的在四已经基本说完了，在这里我对对本门课程的教学理念（OBE）、教学方法（边讲边练）、教学组织（线上线下混合式教学）、教学过程（PTA题目集驱动）及教学模式（BOPPPS) 发表一下我的看法：

相关文章

赞助商

阅读排行

OOP第三次博客总结

一、前言

二、设计与分析

输入样例1:

输出样例1:

输入样例2:

输出样例2:

输入样例3:

输出样例3:

输入样例4:

输出样例4:

输入样例5:

输出样例5:

输入样例6:

输出样例6:

输入样例7:

输出样例7:

输入样例8:

输出样例8:

输入样例9:

输出样例9:

输入格式:

输出格式:

输入样例:

输出样例:

main方法说明

思考

输入样例

输出样例

三、踩坑心得

四、改进建议

五、总结

对课程学习的总结我想说的在四已经基本说完了，在这里我对对本门课程的 教学理念（OBE）、教学方法（边讲边练）、教学组织（线上线下混合式教学）、教学过程（PTA题目集驱动）及教学模式（BOPPPS) 发表一下我的看法：

相关文章

赞助商

阅读排行

对课程学习的总结我想说的在四已经基本说完了，在这里我对对本门课程的教学理念（OBE）、教学方法（边讲边练）、教学组织（线上线下混合式教学）、教学过程（PTA题目集驱动）及教学模式（BOPPPS) 发表一下我的看法：