一、作业总结
前三次的题目集里的作业难度相对而言都简单一些，便于我们入门java，从简易慢慢过渡到中等，最主要是学习到了“类”这个实用而又重要的工具，类似于此前在c语言里学习过的结构体一样，承载着重要的变量和功能。
从整个题目集完成的情况上看来，结果还算可以，但是也遇到了许许多多的问题，还有待我去解决，在菜单计价这一大题类型中的的确确可以学习到很多相关的知识和手段，虽然从中有不小的麻烦和难点，但在参考各类代码总结用法之后也算顺利完成。
总的来说前三次题目集以让我们熟悉过渡为主，初步了解java的算法设计，为之后的学习打下基础。下面进入对这三次作业的简要分析
1.成绩计算-1-类、数组的基本运用（第一次作业）
结构： 运行截图：
源码：
这段代码定义了一个名为 Student的类，它包含学生的学号、姓名以及三门科目的成绩。还实现了计算总分和平均分的方法。
在 Main类中，通过 Scanner类从控制台输入学生信息，然后创建一个包含5个学生对象的数组。通过循环遍历输入的学生信息，将每个学生的信息初始化并赋值给对应的学生对象。
最后，再次通过循环遍历学生数组，打印出每个学生的学号、姓名、总分和平均分。
这道题难度并不是很大，主要是学生类这一功能的实现要求，也算是我们对类的初次接触。
1.成绩计算-2-关联类（第二次作业）
源码;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Student[] newstudent = new Student[9];
Scanner input = new Scanner(System.in);
String ID;
String name;
String map;
int[] scores = new int[2];
double total = 0;
double Daily = 0;
double Final = 0;
double dailyscore = 0;
double finalscore;
double average = 0;
for (int i = 0; i < 9; i++) {
ID = input.next();
name = input.next();
map = input.next();
for (int j = 0; j < 2; j++) {
scores[j] = input.nextInt();
}
total += (int) (0.4 * scores[0] + 0.6 * scores[1]);
Daily += scores[0];
Final += scores[1];
if (i == 2) {
dailyscore = Daily / 3;
finalscore = Final / 3;
average = total / 3;
newstudent[0] = new Student(ID, name, scores, total, dailyscore, finalscore, average);
total = 0;
Daily = 0;
Final = 0;
average = 0;
}
if (i == 5) {
dailyscore = Daily / 3;
finalscore = Final / 3;
average = total / 3;
newstudent[1] = new Student(ID, name, scores, total, dailyscore, finalscore, average);
total = 0;
Daily = 0;
Final = 0;
average = 0;
}
if (i == 8) {
dailyscore = Daily / 3;
finalscore = Final / 3;
average = total / 3;
newstudent[2] = new Student(ID, name, scores, total, dailyscore, finalscore, average);
total = 0;
Daily = 0;
Final = 0;
average = 0;
}
}
for (int i = 0; i < 3; i++) {
System.out.println(newstudent[i].ID + " " + newstudent[i].name + " " + (int) newstudent[i].total + " " +
String.format("%.2f", newstudent[i].dailyscore) + " " + String.format("%.2f", newstudent[i].finalscore) + " " +
String.format("%.2f", newstudent[i].average));
}
}
public static class Student {
String ID;
String name;
int[] scores = new int[2];
double total;
double dailyscore;
double finalscore;
double average;
public Student(String ID, String name, int[] scores, double total, double dailyscore, double finalscore, double average) {
this.ID = ID;
this.name = name;
this.scores = scores;
this.total = total;
this.dailyscore = dailyscore;
this.finalscore = finalscore;
}
}
}
结构及运行截图：
定义了一个名为Student的类，用于表示学生对象。该类包含了学生的ID、姓名、两门课程的成绩、总分、平时成绩、期末成绩和平均分等属性。构造函数用于初始化这些属性，并提供了对应的getter方法用于获取属性值。在main方法中，创建了一个大小为9的Student类型的数组newstudent，用于存储学生对象。使用Scanner类来获取用户输入的学生信息。用户需要依次输入学生的ID、姓名、两门课程的成绩。其中，每个学生的ID和姓名可以是任意字符串，成绩是整型数值。使用for循环遍历学生数组，对每个学生对象进行处理。在每次遍历中，获取当前学生的ID、姓名和成绩信息，并计算出总分、平时成绩、期末成绩和平均分。根据学生的序号，将计算得到的总分、平时成绩、期末成绩和平均分等信息赋值给相应的学生对象，并存储到数组newstudent中。循环结束后，使用for循环遍历newstudent数组，逐个输出每个学生的ID、姓名、总分、平时成绩、期末成绩和平均分。其中，总分和平时、期末成绩为整型数据，平均分保留两位小数。
在这道题目上我遇到了些问题，在平时分和期末成绩的算法实现上不够严谨，导致最后运行结果和题目要求有些出入，在类的定义当中相对题一复杂许多。不仅仅只是简单的求取总分平均分这么简单了，在算法里还要实现相应的嵌套，先存储平时分和期末总成绩，再进行总评成绩的换算。
3.课程成绩统计程序-1（第三次作业）
类图： 结构：
源码：
import java.text.Collator;
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
String s_record = s.nextLine();
ParseInput handle=new ParseInput();
while (!s_record.equals("end")) {
handle.parseInput(s_record);//解析用户输入的每一行数据
s_record = s.nextLine();
}
handle.showStudents();
handle.showCourses();
handle.showClasses();
}
}
class ParseInput{
ArrayList<Student> listStudent=new ArrayList<>();
ArrayList<Course> listCourse=new ArrayList<>();
ArrayList<Class> listClass=new ArrayList<>();
ArrayList<ChooseCourse> listChooseCourse=new ArrayList<>();
public void parseInput(String str){
InputMatching mat=new InputMatching();
int flag=mat.matchingInput(str);
switch (flag){
case 0:System.out.println("wrong format");
break;
//课程信息
case 1:courseMessage(str);
break;
//成绩信息
case 2:gradeMessage(str);
break;
}
}
public void courseMessage(String str){
String letters[]=str.split(" ");
String courseName=letters[0];//课程名
String type=letters[1];//课程类型
String testType=letters[2];//课程考试类型
Course course=new Course(courseName,type,testType);
if(checkCourse(course)){
if(searchCourse(courseName)==null)
listCourse.add(course);
}
}
public void gradeMessage(String str){
String letters[]=str.split(" ");
String stuId= letters[0];//学生学号
String classID= letters[0].substring(0,6);
String name=letters[1];//学生姓名
String courseName=letters[2];//课程名字
//如果该班级第一次出现
if(searchClass(classID)==null){
Class cla=new Class(classID);
listClass.add(cla);
}
Student stu=new Student(classID,stuId,name);
if(!searchStudent(stuId))
listStudent.add(stu);//将学生加入列表中
//课程是否存在
if(searchCourse(courseName)==null){
System.out.println(courseName+" "+"does not exist");
}
//当课程存在时
else if(searchCourse(courseName)!=null){
Course course=searchCourse(courseName);
//考察
if(letters.length==4&&course.testType.equals("考察")){
int finalGrade= Integer.parseInt(letters[3]);
AssessGrade assessGrade=new AssessGrade(finalGrade);
ChooseCourse chooseCourse=new ChooseCourse(course,stu,assessGrade);
if(!searchChooseCourse(name,courseName))
listChooseCourse.add(chooseCourse);
}
//考试
else if(letters.length==5&&course.testType.equals("考试")){
int usualGrade= Integer.parseInt(letters[3]);
int finalGrade= Integer.parseInt(letters[4]);
ExamGrade examGrade=new ExamGrade(usualGrade,finalGrade);
ChooseCourse chooseCourse=new ChooseCourse(course,stu,examGrade);
listChooseCourse.add(chooseCourse);
}
else{
//学号+英文空格+姓名+英文空格+": access mode mismatch"
System.out.println(stuId+" "+name+" "+": access mode mismatch");
}
}
}
public boolean checkCourse(Course course){
int flag1,flag2;
switch(course.getType()){
case "必修":flag1=0;break;
case "选修":flag1=1;break;
default:flag1=-1;break;
}
switch(course.getTestType()){
case "考试":flag2=0;break;
case "考察":flag2=1;break;
default:flag2=-1;break;
}
if(flag1==0&&flag2==0)
return true;
if(flag1==1&&(flag2==0||flag2==1))
return true;
System.out.println(course.getCourseName()+" : course type & access mode mismatch");
return false;
}
public Class searchClass(String classId){
for(Class cls:listClass){
if(cls.getClassId().equals(classId))
return cls;
}
return null;
}
public Course searchCourse(String name){
for(Course course:listCourse){
if(course.getCourseName().equals(name))
return course;
}
return null;
}
public boolean searchStudent(String id){
for(Student stu:listStudent){
if(stu.getId().equals(id))
return true;
}
return false;
}
//查找是否有重复选课成绩
public boolean searchChooseCourse(String stuName,String courseName){
for(ChooseCourse cs:listChooseCourse){
if(cs.student.getStuName().equals(stuName)&&cs.course.getCourseName().equals(courseName))
return true;
}
return false;
}
public void showStudents(){
Collections.sort(listStudent);
for(int i=0;i<listStudent.size();i++){
Student stu=listStudent.get(i);
//从总选课表listChooseCourse中获取该生的选课记录
ArrayList<ChooseCourse> stuCourseSelects=getStudentSelects(stu.getId());
if(stuCourseSelects.size()!=0) {
System.out.println(stu.getId()+" "+stu.getStuName()+" "+getAvgTotalScore(stuCourseSelects));
}
else if(stuCourseSelects.size()==0){
System.out.println(stu.getId()+" "+stu.getStuName()+" "+"did not take any exams");
}
}
}
public void showCourses(){
Collections.sort(listCourse);
for(int i=0;i<listCourse.size();i++){
Course course=listCourse.get(i);
ArrayList<ChooseCourse> stuCourseSelects=getCourseSelects(course.getCourseName());
if(stuCourseSelects.size()!=0){
if(course.testType.equals("考试"))
System.out.println(course.getCourseName()+" "+getAvgUsualScore(stuCourseSelects)+" "+getAvgFinalScore(stuCourseSelects)+" "+getAvgTotalScore(stuCourseSelects));
if(course.testType.equals("考察"))
System.out.println(course.getCourseName()+" "+getAvgFinalScore(stuCourseSelects)+" "+getAvgTotalScore(stuCourseSelects));
}
else if(stuCourseSelects.size()==0){
System.out.println(course.courseName+" "+"has no grades yet");
}
}
}
public void showClasses(){
Collections.sort(listClass);
for(int i=0;i<listClass.size();i++){
Class cls=listClass.get(i);
ArrayList<ChooseCourse> stuCourseSelects=getClassSelects(cls.getClassId());
if(stuCourseSelects.size()!=0){
System.out.println(cls.getClassId()+" "+getAvgTotalScore(stuCourseSelects));
}
else if(stuCourseSelects.size()==0){
System.out.println(cls.getClassId()+" "+"has no grades yet");
}
}
}
public ArrayList<ChooseCourse> getStudentSelects(String id){
ArrayList<ChooseCourse> choose=new ArrayList<>();
for(ChooseCourse cos:listChooseCourse) {
if (cos.student.getId().equals(id))
choose.add(cos);
}
return choose;
}
public ArrayList<ChooseCourse> getCourseSelects(String courseName){
ArrayList<ChooseCourse> choose=new ArrayList<>();
for(ChooseCourse cos:listChooseCourse) {
if (cos.course.getCourseName().equals(courseName))
choose.add(cos);
}
return choose;
}
public ArrayList<ChooseCourse> getClassSelects(String clsId){
ArrayList<ChooseCourse> choose =new ArrayList<>();
for(ChooseCourse cos:listChooseCourse) {
if (cos.student.getClsId().equals(clsId))
choose.add(cos);
}
return choose;
}
public int getAvgTotalScore(ArrayList<ChooseCourse> cs){
int average=0;
int sum=0;
for(ChooseCourse c:cs){
sum+=c.grade.getTotalGrade();
}
average=sum/cs.size();
return average;
}
public int getAvgUsualScore(ArrayList<ChooseCourse> cs){
int average=0;
int sum=0;
for(ChooseCourse c:cs){
if(c.course.getTestType().equals("考试")){
sum+=c.grade.getUsualGrade();
}
}
average=sum/cs.size();
return average;
}
public int getAvgFinalScore(ArrayList<ChooseCourse> cs){
int average=0;
int sum=0;
for(ChooseCourse c:cs){
sum+=c.grade.finalGrade;
}
average=sum/cs.size();
return average;
}
}
class ChooseCourse{
Course course;
Student student;
Grade grade;
public ChooseCourse(Course course,Student student,Grade grade) {
this.course = course;
this.student=student;
this.grade=grade;
}
}
class Student implements Comparable<Student>{
String stuName;
String id;
String clsId;
public String getId(){
return id;
}
public String getStuName(){
return stuName;
}
public String getClsId(){
return clsId;
}
public Student(String clsId,String id,String stuName) {
this.clsId=clsId;
this.id=id;
this.stuName=stuName;
}
public int compareTo(Student stu){
return getId().compareTo(stu.getId());
}
}
class Course implements Comparable<Course>{
String courseName;
String type;
String testType;
public Course() {
}
public Course(String courseName,String type,String testType) {
this.courseName=courseName;
this.type=type;
this.testType=testType;
}
public String getCourseName(){
return courseName;
}
public String getType(){
return type;
}
public String getTestType(){
return testType;
}
@Override
public int compareTo(Course o) {
Comparator<Object> compare = Collator.getInstance(java.util.Locale.CHINA);
return compare.compare(courseName,o.getCourseName());
}
}
class Class implements Comparable<Class>{
String classId;
public Class() {
}
public String getClassId(){
return classId;
}
public Class(String classId) {
this.classId = classId;
}
@Override
public int compareTo(Class o) {
return getClassId().compareTo(o.getClassId());
}
}
abstract class Grade{
int finalGrade;
public Grade() {
}
public abstract int getUsualGrade();
public abstract int getTotalGrade();
}
class ExamGrade extends Grade{
int usualGrade;
public ExamGrade(int usualGrade,int finalGrade) {
this.usualGrade=usualGrade;
this.finalGrade=finalGrade;
}
public int getUsualGrade(){
return usualGrade;
}
public int getFinalGrade(){
return 0;
}
public int getTotalGrade(){
return (int)(usualGrade*0.3+finalGrade*0.7);
}
}
class AssessGrade extends Grade{
public AssessGrade(int finalGrade) {
this.finalGrade=finalGrade;
}
public int getFinalGrade(){
return finalGrade;
}
@Override
public int getUsualGrade() {
return 0;
}
public int getTotalGrade(){
return finalGrade;
}
}
class InputMatching {
static String stuNumMatching = "[0-9]{8}";//8个0-9的数字
static String stuNameMatching = "\\S{1,10}";//1到10个非空格（TAB）字符
static String scoreMatching = "([1-9]?[0-9]|100)";
static String courseNameMatching = "\\S{1,10}";//1到10个非空格（TAB）字符
static String courseTypeMatching = "(选修|必修)";
static String checkCourseTypeMatching = "(考试|考察)";
//courseInput用于定义课程信息模式（正则表达式）
static String courseInput = courseNameMatching + " " + courseTypeMatching + " " + checkCourseTypeMatching;
//scoreInput用于定义成绩信息模式（正则表达式）
static String scoreInput1 = stuNumMatching + " " + stuNameMatching + " " + courseNameMatching + " " +
scoreMatching ;
static String scoreInput2= stuNumMatching + " " + stuNameMatching + " " + courseNameMatching + " " +
scoreMatching + " " +scoreMatching;
public InputMatching() {
}
public int matchingInput(String s) {
if (matchingCourse(s))
return 1;
if (matchingScore(s))
return 2;
return 0;
}
//课程信息
private static boolean matchingCourse(String s) {
return s.matches(courseInput);
}
//成绩信息
private static boolean matchingScore(String s) {
//System.out.println(match);
if(s.matches(scoreInput1)||s.matches(scoreInput2))
return true;
return false;
}
}
运行截图：
Main类是程序的入口，负责读取用户的输入，并调用相应的方法进行处理。Scanner类被用来从标准输入中读取用户的输入，每次读取一行数据。
-
输入解析部分：
ParseInput类负责解析用户输入的数据，并根据输入的内容调用相应的方法进行处理。InputMatching类用于匹配用户输入的数据格式，判断输入的数据是课程信息还是成绩信息。它使用正则表达式来匹配输入的数据格式。matchingInput方法根据输入的数据格式判断是课程信息还是成绩信息。 -
数据存储部分：
Course类表示一个课程，包含课程的名称、类型和考试类型等属性。Student类表示一个学生，包含学生的班级ID、学号和姓名等属性。Class类表示一个班级，包含班级的ID属性。Grade抽象类表示成绩，包含获取平时成绩和总成绩的抽象方法。ExamGrade类和AssessGrade类分别继承自Grade类，表示考试成绩和考察成绩。ChooseCourse类表示学生选择的课程，包含课程对象、学生对象和成绩对象等属性。ArrayList集合被用来存储课程、学生、班级和选择课程的记录等数据。 -
数据处理部分：
checkCourse方法用于检查课程的类型和考试类型是否匹配，如果不匹配则输出提示信息。courseMessage方法解析课程信息，创建课程对象，并加入课程列表中。gradeMessage方法解析成绩信息，创建学生对象和选择课程对象，并加入学生列表和选择课程列表中。searchCourse方法根据课程名字在课程列表中查找课程对象。searchStudent方法根据学生学号在学生列表中查找学生对象。searchChooseCourse方法根据学生姓名和课程名字在选择课程列表中查找选择课程对象。showStudents方法按学号排序输出学生的成绩信息，包括平均总分。showCourses方法按课程名称排序输出课程的成绩信息，包括平均平时成绩、平均期末成绩和平均总分。showClasses方法按班级ID排序输出班级的成绩信息，包括平均总分。getStudentSelects方法根据学生学号获取该学生的选择课程记录。getCourseSelects方法根据课程名称获取该课程的选择课程记录。getClassSelects方法根据班级ID获取该班级的选择课程记录。getAvgTotalScore方法计算选择课程记录中的平均总分。getAvgUsualScore方法计算选择课程记录中的平均平时成绩。getAvgFinalScore方法计算选择课程记录中的平均期末成绩。
这个学生成绩管理系统的实现通过解析用户输入的数据，将课程信息和成绩信息存储在相应的对象中，并提供了一些方法用于统计和输出学生、课程和班级的成绩信息。
这道题是这三套题目集中算最为有难度的一题了，最为困难的主要是其输入的构造及实现。程序通过ParseInput类对用户输入的数据进行解析，并根据输入的内容调用相应的方法进行处理。使用了InputMatching类来匹配用户输入的数据格式，以确保输入的数据格式正确。同时，使用了多个类来表示课程、学生、班级和成绩等信息，并使用ArrayList集合来存储这些对象，方便后续的处理和统计。程序实现了一系列的方法来处理和统计学生、课程和班级的成绩信息。通过搜索和过滤选择课程列表，可以获取指定学生、课程或班级的成绩记录，并进行计算平均分数等统计操作。这些方法通过遍历选择课程列表和相应的对象列表来实现，提供了灵活和高效的数据处理能力。使用了类和方法的封装来组织代码结构，使得不同的功能模块可以独立开发和维护。每个类都有明确的职责和属性，使得代码的可读性和可维护性更高。同时，使用了抽象类和继承的概念，将共同的属性和方法抽象出来，减少了代码的重复性。程序在输出学生、课程和班级的成绩信息时，根据一定的规则对结果进行排序，以确保输出结果的有序性。同时，结果的格式化处理也使得输出结果更加清晰和易读。在学习了大部分网上的相关知识及参考代码才最终做完这一题，但这也使得我收获颇多。
4.面向对象编程(封装性)（第四次作业）
结构： 运行截图：
源码：
主程序部分：Main类是程序的入口，通过Scanner类从标准输入读取用户输入的学生信息。通过无参构造方法和setter方法进行学生对象的创建和属性赋值。通过有参构造方法创建带有初始值的学生对象。调用学生对象的print方法，输出学生的信息。学生类：Student类表示学生，包含学号、姓名、年龄和专业等属性。学生类提供了两个构造方法：一个是无参构造方法，另一个是有参构造方法，用于创建学生对象并初始化属性值。学生类还提供了setter方法用于设置学生对象的属性值。print方法用于输出学生的信息。数据存储和处理：学生类的属性用于存储学生的信息，包括学号、姓名、年龄和专业。通过setter方法将用户输入的数据设置给学生对象的属性。实现了学生信息的创建、属性赋值和输出功能。通过Scanner类从标准输入读取用户输入的学生信息，然后根据输入的内容创建学生对象，并设置学生对象的属性值。最后调用学生对象的print方法将学生信息输出。结构清晰，逻辑简单，实现了基本的学生信息管理功能。这题并不算是很难得题，重点考察学生类的两个构造方式。
二、学到了什么
输入输出流：使用Scanner类从标准输入读取用户输入的数据，然后通过输出语句将结果输出到控制台。
类和对象：通过定义Student类来表示学生对象，并使用类的构造方法和setter方法来创建和初始化学生对象的属性。
构造方法的使用：学生类提供了无参构造方法和有参构造方法，分别用于创建默认值的学生对象和带有初始值的学生对象。
封装和访问控制：学生类的属性（学号、姓名、年龄、专业）被声明为私有属性，并通过公有的setter方法来设置属性的值。
方法的定义和调用：学生类定义了print方法，用于输出学生的信息。通过调用学生对象的print方法，可以将学生的信息输出到控制台。
对象的创建和属性赋值：通过new关键字创建学生对象，并使用setter方法将用户输入的数据赋值给学生对象的属性。
类的组织和文件结构：代码按照不同的类进行组织，每个类都有明确的职责和属性，并使用单独的文件来存储类的定义。
代码的规范和可读性：代码采用了一定的缩进和空行，以增加代码的可读性。同时，方法和变量的命名清晰明确，使代码更易于理解和维护。
综上所述，从这几次的题目集我学习到了与输入输出流、类和对象、构造方法、封装和访问控制、方法的定义和调用、对象的创建和属性赋值等相关的知识。这些知识点是Java基础编程中的重要内容，掌握它们能够帮助我们更好地理解和应用面向对象编程的原理和技术。
标签：题目,String,int,pta,学生,return,课程,java,public From： https://www.cnblogs.com/nchu21207118/p/nchusoftware21207118.html