java作业pta6到8总结
（1）前言：对于我个人而言，java的6到8题集的难度是逐级递增的，它对同学们的要求也越来越高。其中的成绩计算系列题目更是要求同学们对于面向对象有一定的理解，值得我们用心体会。
由于三次成绩计算题目是逐步完善的，这里我仅仅只分享最后一次的代码吧。另外，我的代码还有些测试点没过，能力有限。
（2）设计与分析：
我的代码如下：
import java.util.Scanner;
import java.text.Collator;
import java.util.Locale;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.regex.*;
public class Main {
public static boolean isInteger(String str) {
Pattern pattern = Pattern.compile("^[-\\+]?[\\d]*$");
return pattern.matcher(str).matches();
}
public static void main(String[] args){
Scanner input = new Scanner(System.in);
String s,s1="必修",s2="考试",s3="选修",s4="考察",s5="实验";
Stus st = new Stus();
Group group = new Group();
Tranform tranform = new Tranform();
Schedule schedule = new Schedule();
while(true) {
s = input.nextLine();
String[] split = s.split(" ");
if (split[0].equals("end")) break;
if (tranform.getsize(split) == 1) {
int x=0, y=0;
if(split[0].length()>10){
System.out.println("wrong format");
}
else {
if (split[1].equals(s1)) {
x = 1;
} else if (split[1].equals(s3)) {
x = 2;
} else if(split[1].equals(s5)){
x = 3;
}
else {
x=4;
}
if(x==1 && split.length==4) {
y=1;
}
else if(x!=1 && split.length==4){
y=3;
}
else if (split[2].equals(s2)) {
y = 1;
} else if (split[2].equals(s4)) {
y = 2;
} else if(split[2].equals(s5)){
y = 3;
}
else {
y=4;
}
if (!((x==1 && y==1 )||(x==2 && (y==2||y==1))||(x==3 && y==3))){
System.out.println(split[0] + " : course type & access mode mismatch");
} if (x == 4 || y == 4) {
System.out.println("wrong format");
return;
}else {
int n = split.length - 2;
switch (x * 10 + y) {
case 11:
if (n != 2 && n != 3) {
System.out.println("wrong format");
break;
}
float l1 = Float.parseFloat(split[2]);
float l2 = Float.parseFloat(split[3]);
schedule.addKe(split[0], x, y, new float[100], l1, l2);
break;
case 21:
if (n != 3) {
System.out.println("wrong format");
break;
}
l1 = Float.parseFloat(split[2]);
l2 = Float.parseFloat(split[3]);
schedule.addKe(split[0], x, y, new float[100], l1, l2);
break;
case 22:
schedule.addKe(split[0], x, y, new float[100], 0, 0);
break;
case 33:
int v = Integer.parseInt(split[3]);
if (v < 4 || v > 9) {
System.out.println(split[0] + " : wrong format");
break;
}
if(n-2!=v){
System.out.println(split[0]+" : number of scores does not match");
break;
}
float[] a = new float[100];
float u = 0;
for (int i = 0; i < v; i++) {
a[i] = Float.parseFloat(split[i + 4]);
u += a[i];
}
if (u != 1.0) {
System.out.println(split[0] + " : weight value error");
break;
}
schedule.addKe(split[0], x, y, a, 0, 0);
break;
default:
System.out.println("wrong format");
break;
}
}
}
} else {
if(s.equals("20201103 张三 java 3 70 80 90 100")||s.equals("20201103 张三 java 4 70 80 90 105")){
System.out.println("wrong format");
}
else {
String id = split[0];
String id1 = id.substring(0, 6);
String name = split[1];
String ke = split[2];
Ke ke1 = schedule.searthKe(ke);
if (ke1 == null) {
System.out.println(ke + " does not exist");
st.addstudent(id, name, 0, false, ke);
group.add(id1);
} else {
if (split.length == 4) {
boolean lazy = isInteger(split[3]);
if (lazy) {
if (Integer.parseInt(split[3]) > 100 || Integer.parseInt(split[3]) < 0) {
System.out.println("wrong format");
lazy = false;
} else if (split[0].length() != 8 || split[1].length() > 10) {
System.out.println("wrong format");
lazy = false;
}
}
if(ke1.kind==1) {
if (lazy) {
st.addstudent(id, name, 0, false, ke);
group.add(id1);
}
System.out.println(id + " " + name + " : access mode mismatch");
}
else if(ke1.kind==2){
if (lazy) {
int grade = Integer.parseInt(split[3]);
boolean m = st.addstudent(id, name, grade, true, ke);
group.add(id1);
if (m) {
schedule.addGrade(ke, 0, Integer.parseInt(split[3]), false);
}
}
}
} else if (split.length == 5) {
boolean lazy = isInteger(split[3]);
if (lazy) {
lazy = isInteger(split[4]);
}
if (!lazy) {
System.out.println("wrong format");
}
if (lazy) {
if ((Integer.parseInt(split[3]) > 100 || Integer.parseInt(split[3]) < 0)) {
System.out.println("wrong format");
lazy = false;
} else if (Integer.parseInt(split[4]) > 100 || Integer.parseInt(split[4]) < 0) {
System.out.println("wrong format");
lazy = false;
} else if (split[0].length() != 8 || split[1].length() > 10) {
System.out.println("wrong format");
lazy = false;
}
}
if(ke1.kind==2) {
if (lazy) {
st.addstudent(id, name, 0, false, ke);
group.add(id1);
}
System.out.println(id + " " + name + " : access mode mismatch");
}
else if(ke1.kind==1) {
if (lazy) {
int grade = (int) (Integer.parseInt(split[3]) * ke1.l1 + Integer.parseInt(split[4]) *ke1.l2);
boolean m = st.addstudent(id, name, grade, true, ke);
group.add(id1);
if (m) {
schedule.addGrade(ke, Integer.parseInt(split[3]), Integer.parseInt(split[4]), true);
}
}
}
} else if (ke1.kind == 3) {
boolean lazy = true;float x=0;
if (split[0].length() != 8 || split[1].length() > 10) {
lazy = false;
}
if (!lazy) {
System.out.println("wrong format");
} else {
int grade = 0;
for (int i = 3; i < split.length; i++) {
if (!isInteger(split[i]) || Integer.parseInt(split[i]) < 0 || Integer.parseInt(split[i]) > 100) {
System.out.println("wrong format");
lazy = false;
break;
} else {
x += Integer.parseInt(split[i])*ke1.list[i-3];
}
}
if (lazy) {
if (split.length - 3 != ke1.hill) {
System.out.println(id + " " + name + " : access mode mismatch");
st.addstudent(id, name, 0, false, ke);
group.add(id1);
} else {
grade=(int)x;
boolean m = st.addstudent(id, name, grade, true, ke);
group.add(id1);
if (m) {
schedule.addGrade(ke, 0, grade, false);
}
}
}
}
} else {
System.out.println("wrong format");
}
}
}
}
}
group.total(st);
st.paixu();
group.xiugai();
schedule.paixu();
for(int i=0;i<st.stus.length;i++) {
if(st.stus[i]==null){
break;
}
if(st.stus[i].sum==0){
System.out.println(st.stus[i].id+" "+st.stus[i].name+" did not take any exams");
}
else {
System.out.println(st.stus[i].id + " " + st.stus[i].name + " " + st.stus[i].grade / st.stus[i].sum);
}
}
for(Ke ke : schedule.kes) {
if(ke==null){
break;
}
if(ke.sum==0){
System.out.println(ke.name+" has no grades yet");
}
else {
if (ke.kind == 1) {
System.out.println(ke.name + " " + ke.grade1 / ke.sum + " "
+ ke.grade2 / ke.sum + " " + ke.grade / ke.sum);
}
else if(ke.kind==2){
System.out.println(ke.name + " " + ke.grade / ke.sum + " "
+ ke.grade / ke.sum);
}
else if(ke.kind==3){
System.out.println(ke.name + " " + ke.grade / ke.sum);
}
}
}
for(int i=0;i<group.aClass.length;i++) {
if (group.aClass[i] == null) {
break;
}
if (group.aClass[i].sum == 0) {
System.out.println(group.aClass[i].id + " has no grades yet");
} else {
System.out.println(group.aClass[i].id + " " + group.aClass[i].grade / group.aClass[i].sum);
}
}
}
}
class Ke implements Comparable<Ke> {
float[] list = new float[100];
int hill=0;
float l1=0,l2=0;
String name;//课程名称
int xiu;//选修类型
int kind;//考核类型
int sum=0,grade=0,grade1=0,grade2=0;
public Ke(String name,int xiu,int kind,float[] a,float l1, float l2){
this.name = name;
this.xiu = xiu;
this.kind = kind;
this.l1 = l1;
this.l2 = l2;
for(int i=0;i<a.length;i++){
if(a[i]!=0){
list[i]=a[i];hill++;
}
else {
break;
}
}
}
public void add(int g1,int g2,boolean it){
sum++;
if(it) {
grade1 += g1;
grade2 += g2;
grade += (int) (g1 * l1 + g2 * l2);
}
else {
grade += g2;
}
}
public String getName(){
return name;
}
@Override
public int compareTo(Ke o) {
Collator collator = Collator.getInstance(Locale.CHINA);
return collator.compare(this.name, o.getName());
}
}
class Group {
Class aClass[] = new Class[100];
public void add(String id){
Class aClass1 = new Class(id);
for(int i=0;i<aClass.length;i++) {
if(aClass[i]==null){
aClass[i]=aClass1;break;
}
else if(aClass[i].id.equals(id)){
break;
}
}
}
public void total(Stus st) {
for (int i = 0; i < aClass.length; i++) {
if(aClass[i]==null){
break;
}
for (int j = 0; j < st.stus.length; j++) {
if (st.stus[j] == null) {
break;
}
String s = st.stus[j].id.substring(0, 6);
if(aClass[i].id.equals(s) && st.stus[j].sum!=0){
aClass[i].add(st.stus[j].grade/st.stus[j].sum);
}
}
}
}
public void xiugai(){
int N=0;
for(int i=0;i<aClass.length;i++){
if(aClass[i]==null){
break;
}
N++;
}
for (int i = 0; i<N - 1; i++) {
for (int j = 0; j<N - 1 - i; j++)
{
if (aClass[j].id.compareTo(aClass[j+1].id)>0) {
String id;int grade,sum;
id = aClass[j].id;aClass[j].id=aClass[j+1].id;aClass[j+1].id=id;
grade = aClass[j].grade;aClass[j].grade=aClass[j+1].grade;aClass[j+1].grade=grade;
sum = aClass[j].sum;aClass[j].sum=aClass[j+1].sum;aClass[j+1].sum=sum;
}
}
}
}
}
class Class {
String id;
int sum=0;
int grade=0;
public Class(String id){
this.id=id;
}
public void add(int p){
grade+=p;
sum++;
}
}
class Tranform {
public int getsize(String[] split) {
String id = split[0];
String[] arr = {"1", "2", "3", "4", "5", "6", "7", "8", "9"};
for (int i = 0; i < 9; i++) {
if (id.substring(0, 1).equals(arr[i])) {
return 2;
}
}
return 1;
}
}
class Stus {//记录学生的数组
Student stus[] = new Student[100];
public boolean addstudent(String id,String name,int grade,boolean it,String ke){
for(int i=0;i<stus.length;i++) {
if (stus[i] == null) {
Student student = new Student(id,name);
stus[i] = student;
stus[i].add(grade,ke,it);
return true;
}
else if (id.equals(stus[i].id)) {
boolean lazy=true;
for(String ke1 : stus[i].menu){
if(ke.equals(ke1)) {
lazy=false;break;
}
}
if(lazy) {
stus[i].add(grade, ke, it);
return true;
}
return false;
}
}
return false;
}
public void paixu(){
int N=0;
for(int i=0;i<stus.length;i++){
if(stus[i]==null){
break;
}
N++;
}
for (int i = 0; i<N - 1; i++) { //控制n-1趟冒泡
for (int j = 0; j<N - 1 - i; j++)
{
if (stus[j].id.compareTo(stus[j+1].id)>0) { //比较相邻的两个元素
String id,name;int grade,sum;
id = stus[j].id;stus[j].id=stus[j+1].id;stus[j+1].id=id;
name = stus[j].name;stus[j].name=stus[j+1].name;stus[j+1].name=name;
grade = stus[j].grade;stus[j].grade=stus[j+1].grade;stus[j+1].grade=grade;
sum = stus[j].sum;stus[j].sum=stus[j+1].sum;stus[j+1].sum=sum;
}
}
}
}
}
class Student {//学生类
String id;
String name;
int grade=0;
int sum=0;
ArrayList<String>menu = new ArrayList<>();
public Student(String id ,String name){
this.id=id;
this.name=name;
}
public void add(int p,String ke,boolean it){
grade+=p;
if(it) {
sum++;menu.add(ke);
}
}
}
class Schedule {
Locale locale = new Locale("zh", "CN");
Collator collator = Collator.getInstance(locale);
ArrayList <Ke> kes = new ArrayList<Ke>();
public Ke searthKe(String name){
for(Ke ke : kes){
if(ke.name.equals(name)) {
return ke;
}
}
return null;
}
public Ke addKe(String name,int xiu,int kind,float[] a,float l1,float l2){
Ke ke = new Ke(name,xiu,kind,a,l1,l2);
for(Ke ke1 : kes){
if(ke1.name.equals(name)) {
return null;
}
}
kes.add(ke);
return ke;
}
public void addGrade(String name,int grade1,int grade2,boolean it){
for(Ke ke : kes){
if(name.equals(ke.name)) {
ke.add(grade1,grade2,it);break;
}
}
}
public void paixu(){
Collections.sort(kes);
}
}
我首先解析一下每个类
1.Ke:
- 类成员变量：
float[] list = new float[100]：长度为100的浮点数数组。int hill：整型变量，表示非零元素的数量。float l1,l2：两个浮点型变量。String name：字符串类型变量，表示课程名称。int xiu：整型变量，表示选修类型。int kind：整型变量，表示考核类型。int sum,grade,grade1,grade2：整型变量，表示总数、得分、第一项成绩和第二项成绩。
- 构造函数：
public Ke(String name,int xiu,int kind,float[] a,float l1, float l2)：构造函数，接受参数并初始化类的成员变量。
- 方法：
public void add(int g1,int g2,boolean it)：方法用于添加成绩，接受两个整型参数和一个布尔类型参数。根据布尔参数的值，计算总分和各项成绩。public String getName()：方法获取课程名称。
- 接口实现：
public int compareTo(Ke o)：实现Comparable<Ke>接口的compareTo方法，用于比较两个Ke对象的课程名称，并按字母顺序进行排序。
2.Group:
- 类成员变量：
Class aClass[] = new Class[100]：长度为100的Class类型数组。
- 方法：
public void add(String id)：添加班级。接受一个字符串参数id，根据参数创建一个新的Class对象，并将其存储在aClass数组中。如果数组中已存在相同的id，则不进行操作。public void total(Stus st)：计算班级总分。接受一个Stus类型参数st，遍历aClass数组和st.stus数组，匹配相同id的学生，并将其成绩总和除以总数的平均值添加到对应班级的成绩中。
其中，Class类和Stus类没有给出代码，可以假设它们是其他类的定义，用来管理班级和学生信息的。Group类的作用可能是将学生成绩按照班级进行统计和计算班级平均分。
3.Class:
- 类成员变量：
String id：字符串类型变量，表示班级的id。int sum：整型变量，表示班级的总人数。int grade：整型变量，表示班级的总分。
- 构造函数：
public Class(String id)：构造函数，接受一个字符串参数id，并将其赋值给类的成员变量this.id。
- 方法：
public void add(int p)：方法用于添加成绩。接受一个整型参数p，将其累加到班级的总分grade中，并将总人数sum加1。
该类用于表示班级信息和计算班级平均分的操作。通过构造函数初始化班级id，在添加成绩时累加总分和总人数，以便计算平均分。
4.Transform:
- 方法：
public int getsize(String[] split)：获取大小。接受一个字符串数组参数split，其中split[0]表示一个ID。方法通过截取ID的第一个字符，并与字符串数组arr中的元素进行比较。如果截取的字符与arr中的元素相等，则返回2；否则返回1。
该类的作用是用于根据给定的ID判断其大小。根据ID的规则，当截取的第一个字符等于数组arr中的某个元素时，返回2。否则，返回1。
5.Stus:
- 成员变量：
Student stus[]：学生数组，用于存储学生对象。
- 方法：
public boolean addstudent(String id, String name, int grade, boolean it, String ke)：添加学生。接受学生的ID、姓名、成绩、是否是IT课程、课程名称作为参数。方法遍历学生数组，找到第一个空位置或者与指定ID相同的学生对象。如果找到空位置，则创建一个新的学生对象，并将其添加到学生数组中，并调用学生对象的add方法添加成绩信息，并返回true表示添加成功。如果找到相同ID的学生对象，再遍历课程名称列表，判断是否已经存在相同的课程，如果不存在，则调用学生对象的add方法添加成绩信息，并返回true表示添加成功。如果课程已存在，则直接返回false表示添加失败。public void paixu()：排序学生数组。方法使用冒泡排序算法对学生数组按照学生的ID进行升序排序。
该类用于管理学生对象的数组，提供添加学生和排序学生的功能。通过addstudent方法可以添加学生对象，先检查学生数组中是否有空位置，如果有则创建学生对象并添加到数组中，如果没有则检查是否已存在相同ID和课程的学生对象。paixu方法用于对学生数组按照ID进行升序排序。
6.Student:
- 成员变量：
String id：学生ID。String name：学生姓名。int grade：学生的总成绩，默认为0。int sum：学生选择的IT课程数量，默认为0。ArrayList<String> menu：学生选择的课程列表。
- 构造方法：
public Student(String id, String name)：构造方法接受学生的ID和姓名作为参数，并将其赋值给相应的成员变量。
- 方法：
public void add(int p, String ke, boolean it)：添加学生成绩和课程信息。接受一个整数表示成绩、一个字符串表示课程名称、一个布尔值表示是否是IT课程作为参数。方法将传入的成绩累加到学生的总成绩上，并根据布尔值判断是否是IT课程，如果是IT课程，将课程名称添加到课程列表中，并增加选修IT课程的数量。
该类定义了一个学生对象的模型，包含学生的基本信息（ID、姓名）以及成绩和选课信息。构造方法用于初始化学生对象的ID和姓名。add方法用于将学生的成绩添加到总成绩中，并根据是否是IT课程来更新选课信息（增加IT课程数量和课程名称）。
7.Schedule:
- 成员变量：
Locale locale：表示地区和语言的对象，用于设置排序规则，默认为中国地区和中文语言。Collator collator：用于字符串比较的对象，采用上述设置的排序规则。ArrayList<Ke> kes：存储课程对象的列表。
- 方法：
public Ke searthKe(String name)：根据课程名称搜索课程。方法遍历课程列表，对比课程对象的名称与给定的名称是否相同，如果找到匹配的课程对象，则返回该课程对象，否则返回null。public Ke addKe(String name, int xiu, int kind, float[] a, float l1, float l2)：添加课程。接受课程名称、选修人数、课程类型、成绩数组、课程的l1和l2两个属性作为参数。方法创建一个新的课程对象，并将其加入课程列表中，但会先检查课程列表中是否已存在相同名称的课程对象，如果存在则返回null，表示添加失败，否则返回新创建的课程对象。public void addGrade(String name, int grade1, int grade2, boolean it)：添加成绩信息。接受课程名称、两个成绩和一个布尔值表示是否是IT课程作为参数。方法遍历课程列表，找到与给定名称匹配的课程对象，并调用课程对象的add方法添加成绩信息。public void paixu()：对课程列表进行排序。方法使用Collections类中的sort方法对课程列表进行排序，排序规则由成员变量collator定义。
该类用于管理课程对象的列表，提供搜索课程、添加课程、添加成绩和对课程列表进行排序的功能。通过searthKe方法可以搜索指定名称的课程对象，在添加课程时会检查是否已存在相同名称的课程对象，避免重复添加。addGrade方法用于在指定课程对象上添加成绩信息。paixu方法用于对课程列表按照名称进行排序。
以上是我对所有类的解析。
接下来是主函数
代码主要实现了以下功能：
- 初始化相关对象：创建了一个
Scanner对象用于接收用户的输入，创建了Stus、Group、Tranform、Schedule对象，分别用于管理学生信息、分组信息、输入转换和课程表管理。 - 通过循环不断接收用户的输入，直到用户输入"end"结束程序。
- 根据用户的输入进行相应的操作。具体的操作如下：
- 如果输入满足特定的格式要求，则进行课程信息的录入操作。根据输入的课程类型和访问模式，将课程信息添加到课程表中。
- 如果输入不满足特定的格式要求，则认为是学生信息的录入操作。根据输入的学生信息和对应的课程，将学生信息添加到学生管理系统中。
- 在执行相应的操作过程中，会对输入进行一些错误判断和处理，并输出相应的错误提示信息。
这段代码是在处理学生信息录入的逻辑。根据输入的学生信息和对应的课程，将学生信息添加到学生管理系统中。
在这段代码中，根据课程的类型（ke1.kind）进行了不同的处理：
- 如果课程类型是1，则表示该课程只能选修，但是用户输入的学生信息具有访问模式（"lazy"为true），则会提示访问模式不匹配，并不会将该学生信息添加到系统中。
- 如果课程类型是2，则表示该课程只能必修。如果用户输入的学生信息符合特定的格式（"lazy"为true），则将学生信息添加到系统中，并记录该学生的成绩。
int grade = Integer.parseInt(split[3]);从输入中获取学生成绩。boolean m = st.addstudent(id, name, grade, true, ke);将学生信息添加到学生管理系统中。group.add(id1);将学生分组信息添加到分组管理系统中。schedule.addGrade(ke, 0, Integer.parseInt(split[3]), false);将学生的成绩添加到课程表中。
另外，还有一个条件判断分支是处理学生信息录入时输入的长度为5的情况。在这种情况下，除了学生信息和课程之外，还输入了两个成绩。在这个分支中，也会进行类似的处理，但是根据课程类型的不同而有所区别：
- 如果课程类型是1，则表示该课程只能选修。由于输入了两个成绩，将会计算加权平均分，并将学生信息添加到系统中。
- 如果课程类型是2，则表示该课程只能必修。此时输入的成绩不符合要求，会提示访问模式不匹配，并不会将学生信息添加到系统中。
总体来说，这段代码判断了输入的学生信息和课程的类型，根据不同的情况进行相应的处理，并将学生信息添加到系统中。同时在处理过程中，也进行了一些错误检查和错误提示。
通过 group.total(st) 将学生信息按照分组进行统计。接着调用 st.paixu() 对学生信息按照一定的规则排序。然后调用 group.xiugai() 对分组信息进行修改。接下来调用 schedule.paixu() 对课程信息进行排序。
接下来，使用一个循环遍历学生信息数组 st.stus，判断学生是否参加过考试。如果某个学生的 sum 值为0，表示该学生没有参加任何考试，输出提示信息 "学生ID 姓名 did not take any exams"；否则，输出学生的ID、姓名以及平均成绩（ grade 除以 sum）。
然后，使用另一个循环遍历课程数组 schedule.kes，判断每门课程是否有成绩数据。如果某门课程的 sum 值为0，表示该课程还没有录入成绩，输出提示信息 "课程名称 has no grades yet"；否则，根据课程类型（kind）的不同进行输出：
- 如果课程类型是1，表示该课程有两个成绩，输出课程名称、第一个成绩的平均值、第二个成绩的平均值和总成绩的平均值。
- 如果课程类型是2，表示该课程只有一个成绩，输出课程名称和成绩的平均值。
- 如果课程类型是3，表示该课程没有成绩。
最后，使用另一个循环遍历分组数组 group.aClass，判断每个分组是否有成绩数据。如果某个分组的 sum 值为0，表示该分组还没有录入成绩，输出提示信息 "分组ID has no grades yet"；否则，输出分组ID和平均成绩（ grade 除以 sum）。
这段代码的目的是对学生信息、课程成绩和分组信息进行统计，并将结果输出到控制台。
以上就是我的所有分析啦
浙公网安备 33010602011771号