OO第一次博客作业
OO第一次博客作业
对于Java
目前觉得学的很吃力,比上个学期的C语言难很多,没有那么浅显,必须得下苦功夫,一开始没听懂,后来也没有抓紧跟上.
个人体会:
类和对象:
1,类就像是struct,创造一个群体,对象就是这个群体里命名的一个角色,它拥有这里的属性和行为.
2,类（Class）是对象的蓝图或模板，它定义了对象的属性和方法。而对象（Object）则是根据类创建的实例。
3,类的定义包括：
属性（Fields）：也称为成员变量，用于存储对象的状态信息。
方法（Methods）：定义了对象可以执行的操作。
构造函数（Constructors）：特殊的方法，用于初始化对象的状态。
嵌套类（Nested Classes）：在类内部定义的类。
Java的语法:
1,三个特性:封装,继承,多态
2,public和private
3,get和set方法
前言
第一次题目集:
知识点:
1,考核类设计及类间关系设计
2,用正则表达式来做字符串操作
题目量:
较少,相对于之后两次大作业
难度:
较简单
第二次题目集:
知识点:
1,是第一次大作业增加了多种情况的结果,大体知识点一样
2,学会用动态数组或者哈希表存储数据
题目量:
中等
难度:
中等
第三次题目集:
知识点:
1,多张试卷、多张答卷的信息处理，
新增：学生信息、删除题目信息以及多种异常输入的监测，如答案为空字符、仅有学生信息没有答案内容的空白卷、试卷引用、试题引用错误等。
2,增加了更多类,依然要用正则表达式.
题目量:
较多
难度:
较大,比较麻烦,但是我几乎无从下手
设计与分析
我的第二次大作业和第三次大作业最后一题都没得分,我分析不出什么情况,我就是无从下手,不知道怎么布局,从哪开始写起.
第一次大作业:
我的代码之过了四个测试点,用IDEA生成的类图
类之间简化的关系图:
+----------------+ +----------------+ +---------------+
| Question | | ExamPaper | | AnswerSheet |
+----------------+ +----------------+ +---------------+
| - number |<---->| - questions | | - answers |
| - content | | | | - examPaper |
| - standardAnswer| | | +---------------+
+----------------+ +----------------+
^ |
| |
v v
+----------------+ +---------------+
| Main | | java.util |
+----------------+ | Scanner |
| - examPaper | +---------------+
| - answerSheet |
+----------------+
源码:
import java.util.ArrayList;
import java.util.Scanner;
class Question {
private int number;
private String content;
private String standardAnswer;
public Question(int number, String content, String standardAnswer) {
this.number = number;
this.content = content;
this.standardAnswer = standardAnswer;
}
public boolean checkAnswer(String answer) {
return answer.equals(standardAnswer);
}
public String getContent() {
return content;
}
}
class ExamPaper {
private ArrayList<Question> questions = new ArrayList<>();
public void addQuestion(int number, String content, String standardAnswer) {
Question question = new Question(number, content, standardAnswer);
questions.add(question);
}
public Question getQuestion(int number) {
return questions.get(number - 1);
}
}
class AnswerSheet {
private ExamPaper examPaper;
private ArrayList<String> answers = new ArrayList<>();
public AnswerSheet(ExamPaper examPaper) {
this.examPaper = examPaper;
}
public void addAnswer(String answer) {
answers.add(answer);
}
public void gradeAnswers() {
for (int i = 0; i < answers.size(); i++) {
Question question = examPaper.getQuestion(i + 1);
boolean result = question.checkAnswer(answers.get(i));
System.out.println(question.getContent() + "~" + answers.get(i));
System.out.println(result ? "true" : "false");
}
}
}
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int numQuestions = Integer.parseInt(scanner.nextLine());
ExamPaper examPaper = new ExamPaper();
for (int i = 0; i < numQuestions; i++) {
String line = scanner.nextLine();
String[] parts = line.split("#N:| #Q:| #A:");
int number = Integer.parseInt(parts[1].trim());
String content = parts[2].trim();
String answer = parts[3].trim();
examPaper.addQuestion(number, content, answer);
}
AnswerSheet answerSheet = new AnswerSheet(examPaper);
while (true) {
String answerLine = scanner.nextLine();
if (answerLine.equals("end")) {
break;
}
String answer = answerLine.split("#A:")[1].trim();
answerSheet.addAnswer(answer);
}
answerSheet.gradeAnswers();
scanner.close();
}
}
在这里我分了题目类,试卷类,答卷类,还有主类,然后判断输入和输出.用了正则表达式来匹配寻找.
第二次大作业:
这次加了一些情况,并且要用哈希表来储存数组,我一开始想用哈希表,但用不来,最后,然后又去看动态数组,也是不会,最终就做不出来.
源代码:
import java.util.*;
class Question {
private int number;
private String content;
private String standardAnswer;
public Question(int number, String content, String standardAnswer) {
this.number = number;
this.content = content;
this.standardAnswer = standardAnswer;
}
public boolean checkAnswer(String answer) {
return answer.equals(standardAnswer);
}
public String getContent() {
return content;
}
public int getNumber() {
return number;
}
}
class TestPaper {
private Map<Integer, Question> questions = new HashMap<>();
private Map<Integer, List<TestScore>> scores = new HashMap<>();
private int totalScore;
public void addQuestion(Question question) {
questions.put(question.getNumber(), question);
}
public void addScore(int testNumber, int questionNumber, int score) {
if (!scores.containsKey(testNumber)) {
scores.put(testNumber, new ArrayList<>());
}
TestScore testScore = new TestScore(questionNumber, score);
scores.get(testNumber).add(testScore);
totalScore += score;
}
public boolean checkAnswer(int testNumber, int questionNumber, String answer) {
Question question = questions.get(questionNumber);
if (question != null) {
return question.checkAnswer(answer);
}
return false;
}
public void printAlertIfNecessary() {
if (totalScore != 100) {
System.out.println("alert: full score of test paper" + scores.keySet().iterator().next() + " is not 100 points");
}
}
public void printAnswersAndScores(int testNumber) {
List<TestScore> testScores = scores.get(testNumber);
if (testScores == null) {
System.out.println("The test paper number does not exist");
return;
}
StringBuilder sb = new StringBuilder();
for (TestScore ts : testScores) {
System.out.println(questions.get(ts.getQuestionNumber()).getContent() + "~" + ts.getAnswer() + "~" + ts.isCorrect());
sb.append(ts.getScore()).append(" ");
}
System.out.println(sb.toString() + "~" + totalScore);
}
}
class TestScore {
private int questionNumber;
private String answer;
private int score;
private boolean correct;
public TestScore(int questionNumber, String answer, int score) {
this.questionNumber = questionNumber;
this.answer = answer;
this.score = score;
this.correct = true; // Assume correct until checked
}
public TestScore(int questionNumber, int score) {
this(questionNumber, "answer is null", score);
}
public String getAnswer() {
return answer;
}
public int getScore() {
return score;
}
public int getQuestionNumber() {
return questionNumber;
}
public boolean isCorrect() {
return correct;
}
public void setCorrect(boolean correct) {
this.correct = correct;
}
}
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
Map<Integer, TestPaper> testPapers = new HashMap<>();
int currentTestNumber = -1;
TestPaper currentTestPaper = null;
while (scanner.hasNextLine()) {
String line = scanner.nextLine().trim();
if (line.equals("end")) {
break;
}
switch (line.substring(0, 2)) {
case "#N":
String[] parts = line.split(" ");
int number = Integer.parseInt(parts[0].substring(2));
String content = parts[1].substring(3);
String answer = parts[2].substring(3);
Question question = new Question(number, content, answer);
currentTestPaper.addQuestion(question);
break;
case "#T":
parts = line.split(" ");
String[] scores = parts[1].split("-");
currentTestNumber = Integer.parseInt(parts[0].substring(2));
currentTestPaper = new TestPaper();
for (String score : scores) {
String[] scoreParts = score.split("-");
int questionNumber = Integer.parseInt(scoreParts[0]);
int scoreValue = Integer.parseInt(scoreParts[1]);
currentTestPaper.addScore(currentTestNumber, questionNumber, scoreValue);
}
testPapers.put(currentTestNumber, currentTestPaper);
currentTestPaper.printAlertIfNecessary();
break;
case "#S":
parts = line.split(" ");
currentTestNumber = Integer.parseInt(parts[0].substring(2));
currentTestPaper = testPapers.get(currentTestNumber);
String[] answers = parts[1].substring(3).split(" ");
int answerIndex = 0;
for (TestScore ts : currentTestPaper.scores.get(currentTestNumber)) {
if (answerIndex < answers.length) {
String studentAnswer = answers[answerIndex];
boolean correct = currentTestPaper.checkAnswer(currentTestNumber, ts.getQuestionNumber(), studentAnswer);
ts.setCorrect(correct);
answerIndex++;
} else {
ts.setCorrect(false); // No answer for this question
}
}
break;
default:
System.out.println("Invalid input format");
break;
}
}
scanner.close();
// Print the answers and scores
for (TestPaper testPaper : testPapers.values()) {
testPaper.printAnswersAndScores(currentTestNumber);
}
}
}
我定义了三个类：Question、TestPaper和TestScore。Question类用于存储题目信息，TestPaper类用于存储题目、分数以及答案的检查和打印，TestScore类用于存储题目的得分信息。
主类Main使用Scanner来读取输入，并根据输入的类型创建相应的Question和TestPaper对象。当读取到答卷信息时，它会检查答案并设置TestScore对象的correct属性。最后，对于每个TestPaper对象，程序会打印出题目内容、答案、判题结果和得分信息。
Main类是程序的入口点，它使用Scanner来读取用户输入。程序的执行流程如下：
初始化一个Scanner对象来读取输入。
创建一个HashMap来存储不同试卷的TestPaper对象。
使用while循环来连续读取输入，直到读取到"end"标记。
根据输入的前两个字符（标识符），决定如何处理当前行的输入：
题目信息（#N）：解析题目编号、内容和标准答案，创建Question对象，并添加到当前TestPaper中。
试卷信息（#T）：解析试卷号和题目的分值，初始化一个新的TestPaper对象，并将其存储到testPapers映射中。
答卷信息（#S）：解析答卷的试卷号，获取对应的TestPaper对象。然后读取答案，并更新TestScore对象的correct属性。
在读取完所有输入后，关闭Scanner对象。
遍历testPapers映射中的所有TestPaper对象，并调用它们的printAnswersAndScores方法来打印每个题目的答案和得分信息。
第三次大作业:
增加了更多的情况,要设计更多的类,涉及的类
题目类（Question）：用于保存一道题目的信息以及处理的方法。（与系列 1 相同，无变化）
private int num;// 题号
private String content, // 题目内容
standardAnswer;// 标准答案
boolean matchingStandardAnswers(String answer)：判断是否符合标准答案
（新增）boolean isValid=true;//是否是有效的题目
（新增）void disabled() //当题目被删除，设置题目为失效状态
（新增）ArrayList<Answer> answers //记录所有引用了该题目的答案
试卷题目类（
Question_Paper）：用于保存试卷中的题目信息。由于试卷中的题目序号与题
目本身的题号不一致。且题目在不同试卷中的分值可能不一样，因此，设计试卷题目类。
int p_q_num;//试卷中题目的顺序号
Question question;//题目类的对象，保存题目信息
int question_score;// 题目分值
int judge_markAnswer(String answer) // 判断题目得分
试卷类（
TestPaper）：保存和处理一张试卷的信息以及处理的方法，
int questionNum;// 题目数量
HashMap<String, Question_Paper> questions;//题目清单
void inputQuestion(int num, Question question)：添加一道题目
void printQuestions()：输出题目的内容~标准答案
boolean markQuestion(int num, String answer)：判断第 num 题的正确性。
int sum-保存总分
int questionQuantity-保存题目数量
int getSum()：获得总分
答案类（
Answer）：用于保存答卷中一道答案的信息。
Question_Paper question;
String answer;
boolean mark;// 每一题的正确性
int score=0;// 每一题的得分
void calScore()//计算得分
（新增）void disable() //答案对应的题目失效，判分为 0
答卷类（
AnswerPaper）：保存和处理一张答卷的信息以及处理的方法
TestPaper paper;//试卷信息
String[] answers;//每一题的答案信息boolean[] marks;//每一题的判题结果（对/错）
void printQ_A(int num)：输出第 num 题的题目和答案（卷面答案，非标准答案）
boolean getJudge(int num)：获得第 num 题的判题结果
void printJudges() ：// 输出所有的得分以及总分，以空格分隔
（新增）String stuNum;// 学号
（新增）void printErrorNumQuestion(Answer answer) // 输出试卷中错误题目
号的题目
（新增）void printInvalidQuestion(Answer answer)// 输出失效题目信息
学生类（
Student）（新增）：保存学生的信息
String stuNum, stuName;因为我不会,我只能参考了.
踩坑心得:
第一次的大作业:
我的作答实现了题目要求的功能，但存在一些问题.
题目类（Question）: 实现正确，封装了题目的编号、内容和标准答案，并且提供了检查答案的方法。
试卷类（ExamPaper）: 我的代码中，addQuestion 方法正确地将题目添加到了列表中。但是，getQuestion 方法存在问题。题目的输入顺序与题号不相关，因此不能简单地通过 number - 1 来获取题目。我应该使用一个 HashMap 或 TreeMap 来存储题目，以确保可以根据题号快速检索。
答卷类（AnswerSheet）: 类的实现基本正确，但是缺少了保存判题结果的功能。最好添加一个 ArrayList<Boolean> 来存储每个答案的判题结果，并在 gradeAnswers 方法中填充这个列表。
主类（Main）: 主类中，读取了题目数量并创建了 ExamPaper 实例。但是，题目内容的解析方式需要改进，因为 split 方法中的正则表达式分割符需要用双竖线 || 而不是管道 |。此外，addAnswer 方法在 AnswerSheet 类中正确地添加了答案。
判题和输出: 在 gradeAnswers 方法中，需要先检查 examPaper.getQuestion(i + 1) 是否返回了 null，如果是，则不能进行判题。另外，输出格式需要调整，以符合题目要求的输出样例。
第二次大作业:
发现一个问题,代码中，TestPaper类中的questions映射用于存储题目信息。但是，因为题目的输入顺序与题号不相关，可能存在题目编号的缺失，需要映射能够根据题目编号快速检索对应的Question对象。
第三次大作业:不怎么会写.
改进建议,总结
1,要自己赶上进度,不会的要抓紧自学,碰到一个大的题目无从下手,可以试着拆分,或者再练几个小型的综合设计类题.
2,学会了Java大的基本的一些知识框架,但正则还是一点点
3,要再补上一些知识点
4,对教学的建议:不是很习惯这个上课模式,散,杂,学的感觉不实.
5,我现在进度落后有点大,现在开始赶.
浙公网安备 33010602011771号