第三次Blog作业
1.
（1）前言：这几次的题目集的题量和先前的题目集相当，难度相较于以往的题目集有所提升。这几次题目集的难度主要集中在课程成绩统计程序上，我一开始就没有写好，后面的迭代更是写不出来。
（2）设计与分析：
第八次作业：此次作业是课程成绩统计程序的第一次作业，要求是：
某高校课程从性质上分为：必修课、选修课，从考核方式上分为：考试、考察。
考试的总成绩由平时成绩、期末成绩分别乘以权重值得出，比如平时成绩权重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）成绩平均分只取整数部分，小数部分丢弃
这次作业100分我只拿了13分，同时也导致了我后续的迭代没有写出来。我根据题目所给类图写出了一部分代码，但是既没有完成要求的功能，还有很多处测试点超时了。
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String nex = sc.nextLine();
while (!nex.equals("end")){
String[] str = nex.split(" ");
SelectCourse currentScore;
if (str.length == 3){
new Course(str[0],str[1],str[2]);
}
else if (str.length == 4){
Student currentStudent =new Student(str[0],str[1]);
Course currentCourse = (Course) Course.allCourses.get(str[2]);
if (currentCourse == null){
System.out.println(str[0]+" "+str[1]+":"+str[2]+" does not exist");
continue;
}
try {
currentScore=new SelectCourse(currentCourse,new TestScore(Integer.parseInt(str[3])),currentStudent);
}catch (Exception ex){
continue;
}
currentCourse.addScore(currentScore);
currentStudent.addScore(currentScore);
currentStudent.class1.addScore(currentScore);
} else if (str.length == 5) {
Student currentStudent = new Student(str[0], str[1]);
Course currentCourse = (Course) Course.allCourses.get(str[2]);
if (currentCourse == null) {
System.out.println(str[0] + " " + str[1] + ":" + str[2] + " does not exist");
continue;
}
try{currentScore = new SelectCourse(currentCourse, new TestScore(Integer.parseInt(str[3]), Integer.parseInt(str[4])), currentStudent);
}catch (Exception ex){
continue;
}
currentCourse.addScore(currentScore);
currentStudent.addScore(currentScore);
currentStudent.class1.addScore(currentScore);
}
nex = sc.nextLine();
}
Student.allStudents.sort(new Comparator<Student>() {
@Override
public int compare(Student student, Student t1) {
return student.id- t1.id;
}
});
var newCourse=new ArrayList<Course>(Course.allCourses.values());
newCourse.sort( new Comparator<Course>() {
@Override
public int compare(Course cs1, Course cs2) {
return cs1.name.compareTo(cs2.name);
}
});
Class.allClass.sort(new Comparator<Class>() {
@Override
public int compare(Class aClass, Class t1) {
return aClass.name.compareTo(t1.name);
}
});
for (Student currentStudent:Student.allStudents){
int sumTotalScore=0;
int scoreLength=currentStudent.allScores.size();
for (Object o:currentStudent.allScores){
SelectCourse currentScore = (SelectCourse) o;
sumTotalScore += currentScore.getScore().calculateTotalScore();
}
sumTotalScore/=scoreLength;
System.out.println(currentStudent.id+" "+currentStudent.name+" "+sumTotalScore);
}
for (Course currentCourse:newCourse){
int scoreLength=currentCourse.allScores.size();
if(scoreLength==0) {
System.out.println(currentCourse.name + " has no grades yet");
continue;
}
int sumTotalScore=0,sumScore1=0,sumScore2=0;
for (Object o1:currentCourse.allScores){
SelectCourse currentScore = (SelectCourse) o1;
sumTotalScore += currentScore.getScore().calculateTotalScore();
sumScore1 += currentScore.getScore().score1;
sumScore2 += currentScore.getScore().score2;
}
sumTotalScore/=scoreLength;
sumScore1/=scoreLength;
sumScore2/=scoreLength;
if (sumScore1!=0)
System.out.println(currentCourse.name+" "+sumScore1+" "+sumScore2+" "+sumTotalScore);
else System.out.println(currentCourse.name+" "+sumScore2+" "+sumTotalScore);
}
for (Class currentClass:Class.allClass) {
int sumTotalScore=0;
int scoreLength=currentClass.allScores.size();
if(scoreLength==0) {
System.out.println(currentClass.name + " has no grades yet");
continue;
}
for (Object o:currentClass.allScores){
SelectCourse currentScore = (SelectCourse) o;
sumTotalScore += currentScore.getScore().calculateTotalScore();
}
sumTotalScore/=scoreLength;
System.out.println(currentClass.name+" "+sumTotalScore);
}
}
}
abstract class Father{
String name;
ArrayList allScores = new ArrayList<SelectCourse>();
public Father(String name) {
this.name = name;
}
public Father() {
}
public void addScore(SelectCourse selectCourse){
allScores.add(selectCourse);
}
}
class Course extends Father{
static HashMap allCourses = new HashMap<String,Course>();
String courseMethod,examineMethod;
enum CourseMethod
{必修, 选修;}
enum ExamineMethod
{考试, 考察;}
public Course(String name, String courseMethod, String examineMethod) {
super();
this.name = name;
try {
this.courseMethod = CourseMethod.valueOf(courseMethod).toString();
this.examineMethod = ExamineMethod.valueOf(examineMethod).toString();
}catch (IllegalArgumentException ex){
System.out.println("wrong format");
throw new RuntimeException();
}
if (courseMethod.equals("必修")&&examineMethod.equals("考察")){
System.out.println(name+" : course type & access mode mismatch");
throw new RuntimeException();
}
allCourses.put(name,this);
}
}
class Class extends Father{
static ArrayList<Class> allClass = new ArrayList<Class>();
public Class(String name) {
super(name);
allClass.add(this);
}
}
class Student extends Father{
static ArrayList<Student> allStudents = new ArrayList<Student>();
int id;
Class class1;
public Student(String id, String name) {
this.id = Integer.parseInt(id);
this.name = name;
this.class1 = new Class(id.subSequence(0,6).toString());
allStudents.add(this);
}
}
class SelectCourse{
private Course course;
private Score score;
private Student student;
public SelectCourse(Course course, Score score, Student student) {
this.course = course;
if(course.examineMethod.equals("考试"))
this.score = score;
else this.score = new InspectScore(score.score1, score.score2);
this.student = student;
}
public Course getCourse() {
return course;
}
public Score getScore() {
return score;
}
public Student getStudent() {
return student;
}
}
abstract class Score{
int score1,score2;
public Score(int score) {
this.score2 = score;
}
public Score(int score1,int score2) {
this.score1 = score1;
this.score2 = score2;
}
abstract int calculateTotalScore();
}
class InspectScore extends Score{
public InspectScore(int score) {
super(score);
}
public InspectScore(int score1, int score2) {
super(score1, score2);
}
@Override
int calculateTotalScore() {
return score2;
}
}
class TestScore extends Score{
public TestScore(int score) {
super(score);
}
public TestScore(int score1, int score2) {
super(score1, score2);
}
@Override
int calculateTotalScore() {
return (int) Math.round(0.3 * score1 + 0.7 * score2);
}
}
第九次作业：这次作业的题目是：统计Java程序中关键词的出现次数，要求是：
编写程序统计一个输入的Java源码中关键字（区分大小写）出现的次数。说明如下：
- Java中共有53个关键字（自行百度）
- 从键盘输入一段源码，统计这段源码中出现的关键字的数量
- 注释中出现的关键字不用统计
- 字符串中出现的关键字不用统计
- 统计出的关键字及数量按照关键字升序进行排序输出
- 未输入源码则认为输入非法
这次作业100分我拿了80分，在[]以及,分隔和正常测试中出了错，在代码中，我在设计符号判定时出了错。
import java.util.HashMap;
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Main {
public static void main (String[] args) {
var input = new Scanner(System.in);
var filteredContent = new StringBuilder();
var map = new HashMap<String, Integer>();
String[] keys = {"abstract", "assert", "boolean", "break", "byte",
"case", "catch", "char", "class", "const", "continue",
"default", "do", "double", "else", "enum", "extends", "false",
"final", "finally", "float", "for", "goto", "if", "implements",
"import", "instanceof", "int", "interface", "long", "native", "new",
"null", "package", "private", "protected", "public", "return", "short",
"static", "strictfp", "super", "switch", "synchronized", "this", "throw",
"throws", "transient", "true", "try", "void", "volatile", "while"};
String keyWord = input.nextLine(), exitKeyWord = "exit";
var flag = 0;
while (!keyWord.equals(exitKeyWord)) {
filteredContent.append(keyWord.replaceAll("//.*", " ").replaceAll("\".*\"", " "));
keyWord = input.nextLine();
flag = 1;
}
keyWord = filteredContent.toString().replaceAll("/\\*\\s*.*\\s*\\*/", " ");
keyWord = keyWord.replaceAll("\\[", " ");
keyWord = keyWord.replaceAll("]", " ");
keyWord = keyWord.replaceAll(",", " ");
if (flag == 0) {
System.out.println("Wrong Format");
System.exit(0);
}
for (var key : keys) {
Matcher matcher = Pattern.compile("\\b" + key + "\\b").matcher(keyWord);
var n = 0;
while (matcher.find()) n++;map.put(key, n);
}
for (var key : keys) {
if (map.get(key).intValue() != 0)System.out.println(map.get(key) + "\t" + key);
}
}
}
第十次作业：前两题考察HashMap，都比较简单。第三题是课程成绩统计程序的第二次迭代，没有写出来。第四次是动物发声模拟器（多态），这道题的题目是：
设计一个动物发生模拟器，用于模拟不同动物的叫声。比如狮吼、虎啸、狗旺旺、猫喵喵……。
定义抽象类Animal，包含两个抽象方法：获取动物类别getAnimalClass()、动物叫shout()；
然后基于抽象类Animal定义狗类Dog、猫类Cat和山羊Goat，用getAnimalClass()方法返回不同的动物类别（比如猫，狗，山羊），用shout()方法分别输出不同的叫声（比如喵喵、汪汪、咩咩）。
最后编写AnimalShoutTest类测试，输出：
猫的叫声：喵喵
狗的叫声：汪汪
山羊的叫声：咩咩
其中，在AnimalShoutTestMain类中，用speak(Animal animal){}方法输出动物animal的叫声，在main()方法中调用speak()方法，分别输出猫、狗和山羊对象的叫声。
这道题考察多态，实际上也很简单，注意重写抽象方法是别出错就行了。
public class Main {
public static void main(String[] args) {
Cat cat = new Cat();
Dog dog = new Dog();
Goat goat = new Goat();
speak(cat);
speak(dog);
speak(goat);
}
static void speak(Animal animal){
System.out.println(animal.shout());
}
}
abstract class Animal{
abstract String shout();
abstract Animal getAnimalClass();
}
class Cat extends Animal {
@Override
public String shout() {
return "猫的叫声：喵喵";
}
@Override
Animal getAnimalClass () {
return this;
}
}
class Dog extends Animal{
@Override
String shout () {
return "狗的叫声：汪汪";
}
@Override
Animal getAnimalClass () {
return this;
}
}
class Goat extends Animal{
@Override
String shout () {
return "山羊的叫声：咩咩";
}
@Override
Animal getAnimalClass () {
return this;
}
}
第十一作业：第一题是容器-ArrayList-排序，比较简单，第二题是课程成绩统计程序的第三次，我同样没有写出来。第三题是jmu-Java-02基本语法-03-身份证排序，要求是：
- 输入n，然后连续输入n个身份证号。
- 然后根据输入的是sort1还是sort2，执行不同的功能。输入的不是sort1或sort2，则输出
exit并退出。
输入sort1，将每个身份证的年月日抽取出来，按年-月-日格式组装，然后对组装后的年-月-日升序输出。
输入sort2，将所有身份证按照里面的年月日升序输出
这题把输入的身份证存入数组，利用for循环把需要的信息提取出来。
import java.time.LocalDate;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
var sc=new Scanner(System.in);
var n=Integer.parseInt(sc.nextLine());
var list=new ArrayList<ArrayList<Object>>();
for(int i=0;i<n;i++){
var str=sc.nextLine();
var bornt= LocalDate.of(Integer.parseInt(str.substring(6,10)),
Integer.parseInt(str.substring(10,12)),
Integer.parseInt(str.substring(12,14)));
var tmp=new ArrayList<Object>();
tmp.add(str);
tmp.add(bornt);
list.add(tmp);
}
list.sort((a,b)->{
var a1=(LocalDate)a.get(1);
var b1=(LocalDate)b.get(1);
return a1.compareTo(b1);
});
var next=sc.nextLine();
while(next.startsWith("sort")){
if (next.equals("sort1"))
for (Object i:list)
System.out.println(((ArrayList)i).get(1));
else if (next.equals("sort2"))
for (Object i:list)
System.out.println(((ArrayList)i).get(0));
next=sc.nextLine();
}
System.out.println("exit");
}
}
（3）采坑心得：学到了不少新的函数，然而课程成绩统计程序这类题量相对较大，有后续迭代的题目写不出来是我硬伤，一直难以克服。
（4）改进建议：应该尽量有写注释的习惯，时间长了连自己写的是什么玩意都不能一眼看出来了。而且不管怎么说，还是需要有并且保持攻克难关的意识。
（5）总结：相对与先前了解到了不少新的函数，处理数据的能力得到了提升。对遇到困难应该克服到底这句话有很深感触，迭代作业一下没写出来，后续就更难以为继了。
2。
对教学理念评价
觉得用obe理念教育学生实干、用本事说话而不是单纯的教知识概念这种教学理念很先进。
对教学方法评价
觉得边讲边练这种教学方法对培养学生的把知识应用于实际的动手实践能力有很大的正面帮助。
对教学组织评价
线上线下的混合式教学有助于拓展学生学习内容，但相对于线下讲课，会有更多的学生更不上教学进度。
对教学过程评价
PTA题目集驱动有助于学生自学和巩固知识，但是希望每次题目集结束后能够发参考答案，虽说解题方法绝对不唯一，但不是所有人都能作对所有题，有些题不会做又没有参考答案的话难以从中到东西。
对教学模式评价
BOPPPS模式有助于培养学生的自学能力，但对不善于自学或不习惯自学而又一时无法适应的学生来说就是折磨了，希望完全应用BOPPPS前能有一定时间的缓冲教学。
浙公网安备 33010602011771号