首页 > 其他分享 >第一次blog

第一次blog

时间：2024-04-21 23:48:33浏览次数：20  
标签：String get int 第一次 blog new line public

一.前言
1.前三次题目集的知识点：
（1）利用面对对象编程原理根据题目给的信息以及题目的复杂程度建立对应的类以及在类里加入方法。
（2）使用Java自带的类库运用Scanner类中的方法、regex.Matcher类中的方法、regex.Pattern类中的方法等。
（3）正则表达式的利用，利用正则表达式对题目给出的输入内容经行判断，输出对应结果或把输入内容分离加入到自己创建的类中。
（4）用了循环语句、条件语句等语句来控制程序的逻辑性。
（5）对异常情况的处理，把题目输入的大块字符串分割成一段一段的字符串进行逐个处理，判断出异常情况进行输出。
（6）按照题目要求输出相关结果，判断每道题的正误情况对题目进行批改、计算每张卷子的总分，判断每张卷子的总分是否等于一百等类似的格式输出正确结果。
（7）格式化输出有关结果，在过程中使用了System.out.println等方法来格式化输出学生的得分情况以及每道题的正确情况。
2.题量
（1）第一次大作业：题量较少，易于做完。
（2）第二次大作业：题量中等，需要一定时间。
（3）第三次大作业：题量较多，需要花费大量时间。
3.难度
（1）第一次大作业：难度较小，花费时间不长，较为轻松。
（2）第二次大作业：难度上升，花费时间增长，实现代码时较为费力。
（3）第三次大作业：难度较高，花费时间进一步增长，需要理清思路，设计好类之间的调用关系再实现代码。
二.设计与分析
1.第一次大作业
（1）设计与分析：

本次大作业设计了题目（topic）类，试卷（exam）类，答案（answer）类三个类。题目类用来存储题目所具备的属性编号，内容，标准答案，以及定义了get，set方法来获取和修改这些变量。试卷类用来存储试卷的编号，题目等信息，在试卷类里也定义了get，set方法，还定义了一个判断题目是否正确的方法，接受一个题目的答案，对应上题目的标准答案判断是否相等，以此批改试题。答案类除了上述内容还加入了保存试题判断结果的动态数组，用来存储批改结果便于输出。对应代码如下代码块：
`import java.util.Scanner;
import java.util.ArrayList;
class Topic
{
private int topicID;
private String topicContent;
private String standardAnswer;
public Topic(int topicID,String topicContent,String standardAnswer)
{
this.topicID=topicID;
this.topicContent=topicContent;
this.standardAnswer=standardAnswer;
}
public Topic()
{}
public int getTopicID()
{
return topicID;
}
public String getTopicContent()
{
return topicContent;
}
public String getStandardAnswer()
{
return standardAnswer;
}
public boolean judgeTopic1(String answer)
{
if(answer.equals(standardAnswer))
return true;
else
return false;
}
}
class Exam
{
private ArrayListtopics=new ArrayList<>();
private int topicNumber;
public Exam(ArrayListtopics,int topicNumber)
{
this.topics=topics;
this.topicNumber=topicNumber;
}
public Exam()
{}
public ArrayList getTopics()
{
return topics;
}
public int getTopicNumber()
{
return topicNumber;
}
public void sortTopics()
{
for(int i=0;i<topicNumber-1;i++)
for(int j=0;j<topicNumber-i-1;j++)
if(topics.get(j).getTopicID()>topics.get(j+1).getTopicID())
{
Topic topic=new Topic();
topic=topics.get(j);
topics.set(j,topics.get(j+1));
topics.set(j+1,topic);
}
}
public boolean judgeTopic2(int num,String answer)
{
sortTopics();
return topics.get(num-1).getStandardAnswer().equals(answer);
}

}
class Answer
{
private Exam exam=new Exam();
private ArrayListanswers=new ArrayList<>();
private ArrayListjudgeResult=new ArrayList<>();
public Answer(Exam exam,ArrayListanswers)
{
this.exam=exam;
this.answers=answers;
}
public boolean judgeTopic3(int num)
{
return exam.getTopics().get(num-1).getStandardAnswer().equals(answers.get(num-1));
}
public void printResult(int num)
{
exam.sortTopics();
System.out.println(exam.getTopics().get(num-1).getTopicContent()+"~"+answers.get(num-1));
}
public void saveAnswer(int num, String answer)
{
answers.set(num-1,answer);
}
}
public class Main
{
public static void main(String[] args)
{
Scanner input=new Scanner(System.in);
int topicNumber=input.nextInt();
ArrayListtopics=new ArrayList<>();
input.nextLine();
for(int i=0;i<topicNumber;i++)
{
String line=input.nextLine();
int topicID=Integer.parseInt(line.substring(line.indexOf("#N:")+3,line.indexOf("#Q:")).trim());
String topicContent=line.substring(line.indexOf("#Q:")+3,line.indexOf("#A:")).trim();
String standardAnswer=line.substring(line.indexOf("#A:")+3).trim();
topics.add(new Topic(topicID,topicContent,standardAnswer));
}
Exam exam=new Exam(topics,topicNumber);
exam.sortTopics();
ArrayListanswers=new ArrayList<>();
String[] answersString=new String[topicNumber];
for(int i=0;i<topicNumber;i++)
{
answersString[i]=input.next();
answers.add(answersString[i].replaceAll("#A:",""));
}
Answer answer=new Answer(exam,answers);
for(int i=0;i<topicNumber;i++)
answer.printResult(i+1);
for(int i=0;i<topicNumber-1;i++)
System.out.print(answer.judgeTopic3(i+1)+" ");
System.out.print(answer.judgeTopic3(topicNumber));
}
}`
（2）踩坑心得：

最开始提交发现全为格式错误，仔细检查后发现输出最后一个结果时不用加空格，修改代码使输出循环n-1次，第n次输入没空格的结果。修改后全对。
（3）改进建议：
可以加入正则表达式判断输入的字符串是否符合正确格式，可以简化主函数，将输出结果的相应代码写入试卷类中使主函数不显得累赘。
2.第二次大作业
（1）设计与分析：

本次大作业设计了题目（topic）类，试卷（exam）类，答案（answer），答卷类（answerlist）类四个个类。题目类用来存储题目所具备的属性编号，内容，标准答案，以及定义了get，set方法来获取和修改这些变量。试卷类用来存储试卷的编号，题目等信息，在试卷类里也定义了get，set方法，还定义了一个判断题目是否正确的方法，接受一个题目的答案，对应上题目的标准答案判断是否相等，以此批改试题。答案类除了上述内容还加入了保存试题判断结果的动态数组，用来存储批改结果便于输出。答卷类将试卷所有的题目加入其中，并且把答案列表加入其中，在答案类中定义了方法使对应答案与试题一一对应并且输出对应结果。对应代码如下代码块：
`import java.util.Scanner;
import java.util.ArrayList;
import java.util.HashMap;
class Topic
{
private int topicID;
private String topicContent;
private String standardAnswer;
public Topic(int topicID,String topicContent,String standardAnswer)
{
this.topicID=topicID;
this.topicContent=topicContent;
this.standardAnswer=standardAnswer;
}
public Topic()
{}
public int getTopicID()
{
return topicID;
}
public String getTopicContent()
{
return topicContent;
}
public String getStandardAnswer()
{
return standardAnswer;
}
public boolean judgeTopic1(String answer)
{
if(answer.equals(standardAnswer))
return true;
else
return false;
}
}
class Answer
{
private int answerID;
private Exam exam=new Exam();
private ArrayListanswers;
public Answer(int answerID,ArrayListanswers)
{
this.answerID=answerID;
this.answers=answers;
}
public void setExam(Exam exam)
{
this.exam=exam;
}
public boolean judgeTopic3(int num)
{
return exam.getTopics().get(num-1).getStandardAnswer().equals(answers.get(num-1));
}
public void printResult(int num)
{
exam.sortTopics();
System.out.println(exam.getTopics().get(num-1).getTopicContent()+""+answers.get(num-1)+""+exam.judgeTopic2(num-1));
}
/*public void printPoint(int num)
{
exam.sortTopics();
System.out.println(exam.)
}
*/
}
class Exam
{
private int examID;
private HashMap<Integer,Integer>topicPoints;
public Exam(int examID,HashMap<Integer,Integer>topicPoints)
{
this.examID=examID;
this.topicPoints=topicPoints;
}
public Exam()
{}
public int getExamID()
{
return examID;
}
public ArrayList getTopics()
{

}
public void sortTopics()
{
    ArrayList<Integer>topicIDs=new ArrayList<>(topicPoints.keySet());
    ArrayList<Topic>Topics=new ArrayList<>();
    for(int x:topicIDs)
    {
        Topics.add()
    }
    int topicNumber=topics.size();
    for(int i=0;i<topicNumber-1;i++)
        for(int j=0;j<topicNumber-i-1;j++)
            if(topics.get(j).getTopicID()>topics.get(j+1).getTopicID())
            {
                Topic topic=new Topic();
                topic=topics.get(j);
                topics.set(j,topics.get(j+1));
                topics.set(j+1,topic);
            }
    HashMap<Integer,Integer>tempMap=new HashMap<>(topicPoints);
    topicPoints.clear();
    for(Integer key:topics)
        map.put(key,tempMap.get(key));
}
public boolean judgeTopic2(int num,String answer)
{
    sortTopics();
    ArrayList<Integer>topics=new ArrayList<>(topicPoints.keySet());
    return topics.get(num-1).getStandardAnswer().equals(answer);
}

}
public class Main
{
public static void main(String[] args)
{
int topicNumber=0;
Scanner input=new Scanner(System.in);
ArrayListtopics=new ArrayList<>();
ArrayListanswers=new ArrayList<>();
ArrayListexams=new ArrayList<>();
while(!(String line=input.nextLine()).equals("end"))
{
if(line.startsWith("#N:"))
{
topicNumber++;
int topicID=Integer.parseInt(line.substring(line.indexOf("#N:")+3,line.indexOf("#Q:")).trim());
String topicContent=line.substring(line.indexOf("#Q:")+3,line.indexOf("#A:")).trim();
String standardAnswer=line.substring(line.indexOf("#A:")+3).trim();
topics.add(new Topic(topicID,topicContent,standardAnswer));
}
if(line.startsWith("#T:"))
{
ArrayList
HashMap<Integer,Integer>topicPoints=new HashMap<>();
int sumPoint=0;
for(int i=1;;i++)
{
String part=input.next();
if(partnull)
break;
if(i1)
{
int examID=Integer.parseInt(part.substring(line.indexOf("#T:")+3));
}
else
{
topicPoints.put(Integer.parseInt(part.substring(0,line.indexOf("-"))),Integer.parseInt(part.substring(line.indexOf("-")+1)));
sumPoint+=Integer.parseInt(part.substring(line.indexOf("-")+1));
}
}
exams.add(new Exam(examID,topicPoints));
if(sumPoint!=100)
System.out.println("alert: full score of test paper"+examID+" is not 100 points");
}
if(line.startsWith("#S:"))
{
ArrayListanswersString=new ArrayList<>();
for(int i=1;;i++)
{
String part=input.next();
if(partnull)
break;
if(i1)
{
int answerID=Integer.parseInt(part.substring(line.indexOf("#S:")+3));
}
else
{
answers.add(part.replaceAll("#A:",""));
}
}
answers.add(new Answer(answerID,answersString));
}
}
for(int i=0;i<topicNumber-1;i++)
for(int j=0;j<topicNumber-i-1;j++)
if(topics.get(j).getTopicID()>topics.get(j+1).getTopicID())
{
Topic topic=new Topic();
topic=topics.get(j);
topics.set(j,topics.get(j+1));
topics.set(j+1,topic);
}
for(Answer answer:answers)
{
for(Exam)
for(int i=0;i<topicNumber;i++)
answer.printResult(i+1);
}
}
}
`
（2）踩坑心得：

最开始类之间的调用关系没有使用好，导致出现多种编译错误，后面改正使得调用关系正确，并且改进了答卷类判断试题是否正确的相关方法，使得答卷类的层次以及与其他类之间的调用关系更加清晰，最终获得更高的分数。
（3）改进建议：
试卷类中的判断试题的方法可以将循环嵌套修改为多个循环，减少嵌套层数，使后面代码修改时不会太难并且可复用度高。主函数还是第一次大作业的问题，可以加入一个judgement类判断输入的格式是否符合要求，将每行都使用该类的判断格式方法，可以减少主函数的代码量，减少复杂性。
3.第三次大作业
（1）设计与分析

本次大作业设计了题目（topic）类，试卷（exam）类，答案（answer）类，判断（judgeformat），学生（student）五个个类。题目类用来存储题目所具备的属性编号，内容，标准答案，以及定义了get，set方法来获取和修改这些变量。试卷类用来存储试卷的编号，题目等信息，在试卷类里也定义了get，set方法，还定义了一个判断题目是否正确的方法，接受一个题目的答案，对应上题目的标准答案判断是否相等，以此批改试题。判断类定义一个方法接收一个字符串，判断是否与题目给的格式相同，若是返回一个布尔值。新增一个学生类，内含学生的学号和名字，在答案类中根据学生的学号对应学生的姓名，用定义的get方法获得学生的各种信息。答案类除了上述内容还加入了保存试题判断结果的动态数组，用来存储批改结果便于输出。对应代码如下代码块：
import java.util.ArrayList;
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
class Student
{
private String studentID;
private String name;
public Student(String studentID,String name)
{
this.studentID=studentID;
this.name=name;
}
public Student()
{}
public String getStudentID()
{
return studentID;
}
public String getName()
{
return name;
}
}
class Topic
{
private boolean exist;
private int topicID;
private String topicContent;
private String standardAnswer;
public Topic(int topicID,String topicContent,String standardAnswer)
{
exist=true;
this.topicID=topicID;
this.topicContent=topicContent;
this.standardAnswer=standardAnswer;
}
public Topic()
{}
public boolean getExist()
{
return exist;
}
public int getTopicID()
{
return topicID;
}
public String getTopicContent()
{
return topicContent;
}
public String getStandardAnswer()
{
return standardAnswer;
}
public void deleteTopic()
{
exist=false;
}
}
class Answer
{
private int answerID;
private String studentID;
private Student student;
private Exam exam;
private ArrayListanswerList;
private ArrayListanswerIDList;
private ArrayListtopicPointList;
public Answer(int answerID,String studentID,ArrayListanswerIDList,ArrayListanswerList)
{
this.answerID=answerID;
this.studentID=studentID;
this.answerIDList=answerIDList;
this.answerList=answerList;
student=new Student();
exam=new Exam();
topicPointList=new ArrayList<>();
}
public void setStudent(ArrayListstudents)
{
for(Student student1:students)
{
if(student1.getStudentID().equals(studentID))
{
this.student=student1;
break;
}
this.student=new Student();
}
}
public boolean setExam(ArrayListexams)
{
for(Exam exam1:exams)
{
if(exam1.getExamID()answerID)
this.exam=exam1;
}
if(exam.getExamID()0)
{
System.out.println("The test paper number does not exist");
return false;
}
return true;
}
public void correctExam()
{
int totalScore=0;
int a=0;//a记录当前题目遍历数以对应题目分数
boolean sameNumber;
sameNumber=exam.getTopics().size()answerIDList.size();
for(Topic topic:exam.getTopics())
{
if(topic.getTopicID()0)
{
System.out.println("non-existent question~0");
topicPointList.add(0);
}
else
{
int i;
boolean answerExist=false;
for(i=0;i<answerIDList.size();i++)
if(a+1answerIDList.get(i))
{
answerExist=true;
break;
}
if(!answerExist)
{
System.out.println("answer is null");
topicPointList.add(0);
continue;
}
if(topic.getExist())
{
if(topic.getStandardAnswer().equals(answerList.get(i)))
{
topicPointList.add(exam.getPoints().get(a));
totalScore+=exam.getPoints().get(a);
}
else
topicPointList.add(0);
System.out.println(topic.getTopicContent()+""+answerList.get(i)+""+topic.getStandardAnswer().equals(answerList.get(i)));
}
else
{
topicPointList.add(0);
if(!sameNumber)
System.out.println("answer is null");
else
System.out.println("the question "+topic.getTopicID()+" invalid~0");
}
}
a++;
}
if(student.getStudentID()null)
System.out.println(studentID+" not found");
else
{
System.out.print(student.getStudentID()+" "+student.getName()+"

标签：String,get,int,第一次,blog,new,line,public
From： https://www.cnblogs.com/a2320122/p/18149764

相关文章

  • 第一次blog
    前言：我在大一上学期学习了c语言，然后在下学期学习了第二门语言java,因为之前c语言学的挺一般的，然后在这学期学习java感觉还是挺不简单的，要自学很多东西，在这段时间里，我学习了JAVA的基本语法。逻辑结构的使用，学习了类的使用，和类的基本概念，学会了如何封装程序，使得代码更加严谨，代码也更......
  • Blog1-3
    Blog1-3总结1.前言三个礼拜左右的pta训练，让我成功认知到了学校对java这门课程的重视。总体而言，这三次pta难度都是比较大的，让我的头发掉了一根又一根，而且题目难度跨度太大了，让人有点难以适应，也是因为难度跨度很大，导致分数的分配也不是很均匀。还有就是有些测试点真的有点奇怪，让......
  • 第一次Blog
    一.前言在前三次大作业中，设计的均为我们学习生活中常见的答题判题程序，适用于常见的一些网上答题系统，例如我们常见的学习通考试系统。总结前三次大作业，主要知识点第一则为类。利用类能够很好的解决前三次大作业的问题。在后两次大作业中则额外考查了动态数组，链表以及hashmap的知识......
  • OOP课程第一次Blog
    目录1.前言：2.设计与分析：第一次大作业7-5：第一次大作业7-5总结：第二次大作业7-4：第二次大作业7-4总结：第三次大作业7-3：第三次大作业7-3总结：3.踩坑心得：4.改进建议：5.总结：1.前言：题目集1：这次的作业题目量较大，而且最后一题难度不小，然后是第一次使用Java语言编写代码，对于类的使用以及Java的......
  • 第一次blog
    一、作业总结从难度来看，这三次的大作业最后一题都是由一种题目发展扩充来的，不断的深入。因为每次的最后一题涉及的范围越来越广、对每条输入的格式严格要求以及在不同情况下输出不同的语句，所以显而易见的，三次作业的难度在逐渐提升，这也就代表着我们需要更好的思维和逻辑以及方法。......
  • 第一次题目总结
    前言：本次发布的题目集1-3，主要是对类和对象的使用的考察，题量比较适中，难度设置合理，如风扇类设计比较简单，整体就是为了熟悉类的使用，后续的题目加入了一些要求，加强对类和对象的熟悉，难点集中在每次的答题系统迭代上，非常考验类之间的关联使用。每次题目集都会有一些简单的基础题目来熟......
  • 第一次Blog
    前言:个人感觉第一次练习主要是类的构建和相互运用的基础练习，像是第一题便是从风扇类的构建入手，然后逐渐添加对类的运用和类之间关联的需求，最后一题除了是这些需求的结合版以外，还是接下来两次练习最后一题的基底第二次练习在第一次练习的基础上不仅增加了类与类之间关系掌握和......
  • 第一次Blog
    （1）前言：面向对象程序设计（java）是一种区别于c语言的设计语言，其最大的区别便是c语言为面向过程，逻辑为线性逻辑，而java将所要进行的操作分散到各个类当中去，分别完成某项任务，直观的讲便是，c语言是一条简单的流水线，这条流水线上便可完成所有内容，故为线性逻辑，而java则是一座大型工厂，里面有不......
  • OOP课程第一次vlog-23201914-钱文浩
    一、前言1.知识点：第一次题目初步考察了正则表达式，其中包括正则表达式的判断（matches函数）和分割（split函数）。初步考察了类与对象的设计，比如实体类（试卷类，题目类等）、控制类（改卷类等），考查学生对实际问题的需求提取与分析。第二次题目进一步加强对上述各方面内容的考察。而且因为题目加......
  • 23201228-第一次Blog
    一、前言：从大一下学期开始学习java到现在，已经完成了三次PTA用java实现的大作业，三次PTA作业的难度在逐渐增大，每次最后一题都是从第一次PTA大作业里迭代而来，难度很大且每次提升，涉及的内容有很多，比如类，方法，Arraylist等，但最主要的还是类的设计，通过这三次作业，很深刻的认识的了设计对于......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99