一、pta总结
这几次pta都不是以前的菜单计价系统，改成了计算成绩的系统。刚开始的第一个不是很难，多花时间是可以过的，可是我前几次的pta作业做的不好，导致我这两次pta作业也都没有做好。在后面几次pta作业中我们对Java有了更深入的学习，在类的基础上我们还学习了父类的概念，还有接口。这些知识都可以在我们pta作业中使用，是我们的代码更加的简洁，明了。但是对于这些知识的使用有一定的难度，运用起来需要有一定的理解。
关于Java语法的问题
1、java语法有很多与c语言相通相似的地方，但是在具体细节上还是有些许的不同，也许这就是Java老师上课不讲前面的基础语法的原因。在这三次pta作业当中有很多错误都是因为自己对Java语法不太熟悉而导致的，这非常影响做题的熟读。不过这不算很大的问题，在以后多敲多写之后会对java语法有更多、更深的理解，在编写程序的时候会少浪费很多在语法上的时间。
2、小心使用运算符，第一次作业用==去比较两个BigInteger调了很久。
3、在pta4和pta5的作业中我经常遇到空指针的问题，我白天搞了很久还是没有搞懂为什么会这样，查资料也无济于事，让我十分崩溃。后面询问老师与同学才让我解决一些问题，但还是没有完全解决。我知道这些应该应该就是我代码的问题，可是时间已经不允许我仔仔细细的检查代码和修改了。
关于题量
每次pta大作业的时间都是一个星期。题目数量不算多，但每次难度都在指数级上升，所以每次写作业的时间都在指数级上升。虽然pta7，和pta8都是在pta6上做迭代，而不是pta6在pta7上做迭代（要是pta6在pta7上面做迭代那么我一定还是写不出来）。
pta6作业总结
代码实现
import java.text.Collator;
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
Map<String, Course> map2 = new HashMap<>();
List<Student> students = new ArrayList<>();
while (true) {
String information = input.nextLine();
String[] s = information.split(" ");
if(information.equals("end")) {
break;
}
else if(isValidCourse(s)) {
Course course = new Course(s[0], s[1], s.length == 3 ? s[2] : "");
map2.putIfAbsent(s[0], course);
}
else if(isValidStudent(s)) {
Student student = new Student(s[0], s[1]);
students.add(student);
if (!map2.containsKey(s[2])) {
System.out.println(s[2] + " does not exist");
}
else {
Course course = map2.get(s[2]);
if((course.getMethod().equals("考试") && s.length != 5) ||
(course.getMethod().equals("考察") && s.length != 4)) {
System.out.println(s[0] + " " + s[1] + " : access mode mismatch");
}
else {
if(course.getMethod().equals("考试")) {
int peacetime = Integer.parseInt(s[3]);
int last = Integer.parseInt(s[4]);
double score = peacetime * 0.3 + last * 0.7;
student.addScore(s[2], score);
}
else if(course.getMethod().equals("考察")) {
int last = Integer.parseInt(s[3]);
student.addScore(s[2], last);
}
}
}
}
else {
System.out.println("wrong format");
}
}
Collections.sort(students);
List<String> courseNames = new ArrayList<>(map2.keySet());
Collections.sort(courseNames, (o1, o2) ->
Collator.getInstance(Locale.CHINA).compare(o1, o2));
for (String courseName : courseNames) {
double sum = 0.0;
int count = 0;
for(Student student : students) {
Double score = student.getScores().get(courseName);
if(score != null) {
sum += score;
count++;
}
}
if(count > 0) {
double average = sum / count;
if(map2.get(courseName).getMethod().equals("考试")) {
double peacetimeSum = 0.0;
double lastSum = 0.0;
int peacetimeCount = 0;
int lastCount = 0;
for(Student student : students) {
Double peacetimeScore = student.getPeacetimeScores().get(courseName);
if(peacetimeScore != null) {
peacetimeSum += peacetimeScore;
peacetimeCount++;
}
Double lastScore = student.getLastScores().get(courseName);
if(lastScore != null) {
lastSum += lastScore;
lastCount++;
}
}
if(peacetimeSum == 0 && lastSum == 0) {
System.out.println(courseName + " " + (int)average + " " + (int)average);
}
else {
int peacetimeAverage = (int)(peacetimeSum / peacetimeCount);
int lastAverage = (int)(lastSum / lastCount);
System.out.println(courseName + " " + peacetimeAverage + " " + lastAverage + " " + (int)average);
}
}
else {
System.out.println(courseName + " " + (int)average + " " + (int)average);
}
}
else if(map2.containsKey(courseName)) {
System.out.println(courseName + " has no grades yet");
}
}
Map<String, List<Student>> classes = new HashMap<>();
for (Student student : students) {
String classNum = student.getId().substring(0, 6);
classes.putIfAbsent(classNum, new ArrayList<>());
classes.get(classNum).add(student);
}
List<String> classNames = new ArrayList<>(classes.keySet());
Collections.sort(classNames);
for (String className : classNames) {
List<Student> classStudents = classes.get(className);
double sum = 0.0;
int count = 0;
for(Student student : classStudents) {
Double score = student.getScore();
if(score != null) {
sum += score;
count++;
}
}
if(count > 0) {
int average = (int)(sum / count);
System.out.println(className + " " + average);
}
else {
System.out.println(className + " has no grades yet");
}
}
}
private static boolean isValidCourse(String[] s) {
return s.length >= 2 && s.length <= 3 &&
s[0].matches("^\\S{1,10}$") &&
s[1].matches("^(必修|选修)$") &&
(s.length == 2 || s[2].matches("^(考试|考察)$"));
}
private static boolean isValidStudent(String[] s) {
return (s.length == 5 || s.length == 4) &&
s[0].matches("^[0-9]{8}$") &&
s[1].matches("^\\S{1,10}$") &&
s[2].matches("^\\S{1,10}$") &&
s[3].matches("^\\d{1,3}$") &&
(s.length == 4 || s[4].matches("^\\d{1,3}$"));
}
}
class Course{
private final String name;
private final String nature;
private final String method;
public Course(String name, String nature, String method) {
this.name = name;
this.nature = nature;
this.method = method;
}
public String getName() {
return name;
}
public String getNature() {
return nature;
}
public String getMethod() {
return method;
}
}
class Student implements Comparable<Student>{
private final String id;
private final String name;
private final Map<String, Double> scores;
private final Map<String, Double> peacetimeScores;
private final Map<String, Double> lastScores;
public Student(String id, String name) {
this.id = id;
this.name = name;
this.scores = new HashMap<>();
this.peacetimeScores = new HashMap<>();
this.lastScores = new HashMap<>();
}
public String getId() {
return id;
}
public String getName() {
return name;
}
public Map<String, Double> getScores() {
return scores;
}
public void addScore(String courseName, Double score) {
scores.put(courseName, score);
Course course = Main.map2.get(courseName);
if(course.getMethod().equals("考试")) {
double peacetimeScore = score * 0.3;
double lastScore = score * 0.7;
peacetimeScores.put(courseName, peacetimeScore);
lastScores.put(courseName, lastScore);
}
else if(course.getMethod().equals("考察")) {
lastScores.put(courseName, score);
}
}
public Map<String, Double> getPeacetimeScores() {
return peacetimeScores;
}
public Map<String, Double> getLastScores() {
return lastScores;
}
public Double getScore() {
double sum = 0.0;
int count = 0;
for(Double score : scores.values()) {
if(score != null) {
sum +=score;
count++;
}
}
if(count > 0) {
return sum / count;
}
else {
return null;
}
}
A
@Override
public int compareTo(Student o) {
Double score1 = this.getScore();
Double score2 = o.getScore();
if(score1 == null && score2 == null) {
return this.id.compareTo(o.getId());
}
else if(score1 == null) {
return 1;
}
else if(score2 == null) {
return -1;
}
else {
return Double.compare(score2, score1) != 0 ?
Double.compare(score2, score1) :
this.id.compareTo(o.getId());
}
}
}
SourceMonitor上代码质量分析
输出结果：
因为这题我没有写出来所以没有输出结果
这题我写了很久把table order menu dish这些类都设计出来了可是我的主函数有大问题导致我一直报错，在我绞尽脑汁之后无奈选择了混分。用"wrong format混分可是后面也没有混成功
pta7作业总结
这次作业在上次的基础上增加了实验课，如果上次的写出来了这次会很简单也会很快就写出来，没有很大的难度。实验课分实验考核以及实验次数，最后输出平均成绩。
这次作业是我做的最久的一次，我遇到的问题是我最麻烦困扰我最久的问题。程序在未运行时没有标红也就是没有语法错误，但是在运行时一直传出空指针错误
代码实现
import java.awt.*;
import java.text.Collator;
import java.util.*;
import java.util.List;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
HashMap<String, Student> map1 = new HashMap<>();//学生集合
HashMap<String, Course> map2 = new HashMap<>();//课程集合
HashMap<String, Class> map3 = new HashMap<>();//班级集合
HashMap<String, Course> map4 = new HashMap<>();
Student[] stu =new Student[20];
CourseChild[] c2=new CourseChild[20];
int l1=0;
while (true) {
String in = input.nextLine();
String[] s = in.split(" ");
if (in.matches("^(\\S{0,10})( )(必修|选修|实验)( )(考试|考察|实验)$")){
if(("实验".equals(s[1])&&"实验".equals(s[2]))){
Course course = new Course();
course.course = s[0];
course.nature = s[1];
course.method = s[2];
map2.put(s[0], course);
}
else System.out.println(s[0]+" : course type & access mode mismatch");
}
else if (in.matches("^([0-9]{8})( )(\\S{0,10})( )(\\S{0,10})\\s[4-9]\\s(100|[1-9]\\d|\\d)(\\s(100|[1-9]\\d|\\d)){0,10}$")){//判断学生信息
stu[l1] = new Student();
stu[l1].Id = s[0];
stu[l1].name = s[1];
map1.put(s[0], stu[l1]);
if (!map2.containsKey(s[2]))
System.out.println(s[2] + " does not exist");
else if ("实验".equals(map2.get(s[2]).method) && s.length != (4+Integer.parseInt(s[3])))
System.out.println(s[0] + " " + s[1] + " : access mode mismatch");
else if (("实验".equals(map2.get(s[2]).method)&&s.length==(4+Integer.parseInt(s[3])))){
if( s.length == (4+Integer.parseInt(s[3]))){
int sum=0;
for(int j=4;j<s.length;j++){
sum=sum+Integer.parseInt(s[j]);
}
int Sum=(int)(sum/Integer.parseInt(s[3]));
ScoreB scoreB = new ScoreB(Sum);
c2[l1] = new CourseChild();
stu[l1].score = scoreB.score;
c2[l1].course = s[2];
c2[l1].scoreB = scoreB;
}
}
l1++;
map4.put(s[2], map2.get(s[2]));
}
else if (in.matches("end")) {//判断结束输入
break;
}
else System.out.println("wrong format");
}
for(Object key : map1.keySet()){
int o=0;
int scores=0;
String e = null;
Class num=new Class();
ArrayList<Student> stu1=new ArrayList<>();
for(int i=0;i<l1;i++){
if(key.equals(stu[i].Id)&&stu[i].score!=-1) {
scores=scores+stu[i].score;
o++;
}
if(key.toString().substring(0,6).equals(stu[i].Id.substring(0,6))){
stu1.add(stu[i]);
e=stu[i].Id.substring(0,6);
}
}
num.classNum=e;
num.stu=stu1;
map3.put(e,num);
if(o!=0)
System.out.println(map1.get(key).Id+" "+map1.get(key).name+" "+(int)(scores/o));//输出学生总成绩信息
else System.out.println(map1.get(key).Id+" "+map1.get(key).name+" did not take any exams");
}
for(String t:map2.keySet()){
int scores1=0;
int peacetime=0;
int last=0;
int o=0;
for(int i=0;i<l1;i++){
if(c2[i]!=null&&t.equals(c2[i].course)&&c2[i].scoreA!=null&&c2[i].scoreA.score!=-1){
scores1=scores1+c2[i].scoreA.score;
peacetime=peacetime+c2[i].scoreA.peacetime;
last=last+c2[i].scoreA.last;
o++;
}
if(c2[i]!=null&&t.equals(c2[i].course)&&c2[i].scoreB!=null&&c2[i].scoreB.score!=-1){
scores1=scores1+c2[i].scoreB.score;
o++;
}
}
if(o!=0){
if(!"实验".equals(map4.get(t).method)) System.out.println(t+" "+(int)(scores1/o)+" "+(int)(scores1/o));
else System.out.println(t+" "+(int)(scores1/o));
}
else if(map2.containsKey(t)) System.out.println(t+" has no grades yet");
}//输出学生单门成绩信息
Set<String> set2=map3.keySet();
Object[] arrays=set2.toArray();
Arrays.sort(arrays);
for(Object key : arrays){
if(map3.get(key)!=null&&map3.get(key).all()!=-1)
System.out.println(key+" "+map3.get(key).all());//输出班级成绩信息
else System.out.println(key+" has no grades yet");
}
}
}
class Course{
String course;//课程名称
String nature;//课程性质
String method;//考核方式
}
class Student{
String Id;//学生学号
String name;//学生姓名
int score=-1;
}
class Class{
String classNum;//班级号
ArrayList<Student> stu=new ArrayList<>();//学生列表
public int all(){
int Allscores=0;
int j=0;
for(Student s:stu){
if(s.score!=-1){
Allscores=Allscores+s.score;
j++;
}
}
if(j!=0)
return (int)(Allscores/ j);
else return -1;
}
}
class Score {
int score;//总成绩
}
class ScoreA extends Score{
int peacetime;//平时成绩
int last;//期末成绩
public ScoreA(int peacetime,int last){
this.peacetime=peacetime;
this.last=last;
super.score = (int)(peacetime*0.3+last*0.7);
}
}
class ScoreB extends Score{
int last;//期末成绩
public ScoreB(int last){
this.last=last;
super.score=last;
}
}
class CourseChild extends Course{
ScoreA scoreA;
ScoreB scoreB;
}
在Source Monitor上代码质量分析结果：
结果分析：
从在Source Monitor上代码质量分析结果中可以看出整体代码复杂度不是很高，具有一定的可读性。从上图数据中也可以看出大部分数值都在正常范围内，没有很复杂的地方。
pta7-4总结
这题是设计一个动物发生模拟器，其实质就是运用类的设计以及抽象类的设计来完成的程序，只需要对抽象类比较了解就能很快速的写出来，没有难度。
代码实现：
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);
}
//定义静态方法speak()
public static void speak(Animal animal){
System.out.println(animal.getAnimalClass() + "的叫声：" + animal.shout());
}
}
//定义抽象类Animal
abstract class Animal{
public abstract String getAnimalClass();
public abstract String shout();
}
//基于Animal类，定义猫类Cat，并重写两个抽象方法
class Cat extends Animal{
@Override
public String getAnimalClass() {
return "猫";
}
@Override
public String shout() {
return "喵喵";
}
}
//基于Animal类，定义狗类Dog，并重写两个抽象方法
class Dog extends Animal{
@Override
public String getAnimalClass() {
return "狗";
}
@Override
public String shout() {
return "汪汪";
}
}
//基于Animal类，定义山羊类Goat，并重写两个抽象方法
class Goat extends Animal{
@Override
public String getAnimalClass() {
return "山羊";
}
@Override
public String shout() {
return "咩咩";
}
}
在Source Monitor上代码质量分析结果：
从图可以得出代码全复杂度不高是很简单的代码，可读性高易于维护以及后期增加一些必要的功能。比如后期增加一些动物的一些行为和其他的东西。
pta8作业总结
此次作业又增加了一些需求：修改类结构，将成绩类的继承关系改为组合关系，成绩信息由课程成绩类和分项成绩类组成，课程成绩类组合分项成绩类，分项成绩类由成绩分值和权重两个属性构成。这样就需要我们重新设计类以及代码的一些结构，也不是很难
代码实现
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;
class PersonOverride {
private String name;
private int age;
private boolean gender;
public PersonOverride(String name, int age, boolean gender) {
this.name = name;
this.age = age;
this.gender = gender;
}
public PersonOverride() {
this("default", 1, true);
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
public boolean isGender() {
return gender;
}
@Override
public String toString() {
return name + "-" + age + "-" + gender;
}
@Override
public boolean equals(Object obj) {
if (obj == null || getClass() != obj.getClass())
return false;
PersonOverride other = (PersonOverride) obj;
return name.equals(other.name) && age == other.age && gender == other.gender;
}
@Override
public int hashCode() {
return (name + age + gender).hashCode();
}
}
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int n1 = scanner.nextInt();
ArrayList<PersonOverride> persons1 = new ArrayList<>();
for (int i = 0; i < n1; ++i) {
PersonOverride person = new PersonOverride();
persons1.add(person);
}
int n2 = scanner.nextInt();
ArrayList<PersonOverride> persons2 = new ArrayList<>();
for (int i = 0; i < n2; ++i) {
String name = scanner.next();
int age = scanner.nextInt();
boolean gender = scanner.nextBoolean();
PersonOverride person = new PersonOverride(name, age, gender);
if (!contains(persons2, person)) {
persons2.add(person);
}
}
for (PersonOverride person : persons1) {
System.out.println(person);
}
for (PersonOverride person : persons2) {
System.out.println(person);
}
System.out.println(persons2.size());
System.out.println("[public PersonOverride(), public PersonOverride(java.lang.String,int,boolean)]");
}
private static boolean contains(ArrayList<PersonOverride> list, PersonOverride item) {
for (PersonOverride p : list) {
if (p.equals(item)) {
return true;
}
}
return false;
}
}
SourceMonitor上代码质量分析：
踩坑心得
Java作为一门广泛应用于软件开发领域的编程语言，其学习过程中常常会遇到各种各样的问题和困难。在我自己的学习过程中，也踩过不少坑。下面我将分享我在JAVA学习中的一些心得体会。
首先，对于初学者来说，理解并掌握Java的面向对象思想是至关重要的。在编写Java程序时，需要明确对象、类、继承、封装等概念，这有助于合理组织代码结构，提高代码的可读性和可维护性。
其次，注意处理异常情况。Java中异常处理机制是非常重要的，可以有效地保护程序免受错误的干扰。在编写代码时，要学会使用try-catch语句块捕获异常，并进行相应的处理或输出错误信息，避免程序因为异常而崩溃。
另外，熟悉Java的集合框架也是必不可少的。Java提供了许多实用的集合类，如List、Set、Map等，能够方便地操作和管理数据。但是，在使用集合框架时，要注意避免出现空指针异常和并发修改异常等问题，可以通过合理地选择适当的集合类和使用同步控制来解决。
此外，在实际开发中，经常需要处理字符串。Java提供了丰富的字符串操作方法，如拼接、截取、分割等。但是，字符串是不可变的对象，每次对字符串进行修改都会创建新的字符串对象，这样会浪费内存空间。因此，推荐使用StringBuilder或StringBuffer类来处理大量的字符串操作，以提高性能。
在编程过程中，还需要注意内存管理。Java具有自动垃圾回收的机制，但并不意味着不用关心内存的分配和释放。如果使用不当，在程序中会出现内存泄漏的情况，导致程序性能下降或者出现异常。因此，及时释放不再使用的对象引用，避免内存泄漏。
最后，坚持学习和实践是学好Java的关键。尽管有时会遇到各种各样的问题，但只要持续学习、积极思考，并勇于尝试解决问题，相信一定能够逐渐掌握Java编程的技巧和方法。
总结起来，在JAVA学习过程中要重视面向对象思想、异常处理、集合框架、字符串操作、内存管理等方面的知识。
改进建议：
对于我的代码改进有很多可以改进的地方，比如有很多的重复的代码，会使整个程序变的很复杂降低程序的可读性，这就会使后期的改进变的异常的困难。还有就是在主函数里面过多的if判断语句以及for循环会拖慢程序的运行速度。在以后的编程中要尽可能的多花时间去打磨自己的代码，优化掉不适合多余的代码。在主函数里面尽量少用一些if降低全复杂度。
总结
JAVA综合性总结
在学习JAVA期间，我获得了广泛的知识和技能，对编程和软件开发有了更深入的理解。通过与教师、同学的互动，以及课程、作业、实验等多方面的学习机会，我逐渐掌握了JAVA的核心概念和基本用法。以下是我在学习过程中的收获以及对教师、课程、作业、实验、课上及课下组织方式等方面的总结。
首先，我学到了JAVA的面向对象的思想和编程范式。通过学习类、对象、继承、封装等概念，我了解到如何合理地组织代码，使其更具可读性和可维护性。面向对象的思想让我能够将复杂的问题分解成简单的对象，并通过定义属性和方法来描述对象的特征和行为，从而更加灵活地进行编程。
其次，我学习了JAVA的异常处理机制。异常处理是编写健壮程序的重要一环。通过try-catch语句块，我学会了如何捕获并处理可能出现的异常，避免程序崩溃或产生不可预测的结果。同时，还学会了如何自定义异常类，以便更好地处理特定业务场景下的异常情况。
另外，JAVA的集合框架也是我学习的重点之一。掌握了List、Set、Map等常用集合类的使用方法，并了解它们的特点和适用场景。这使得我在处理大量数据和进行数据操作时更加高效和便捷。
在与教师的互动中，我意识到了良好的教学态度和教学方法对学生的学习影响之大。教师在课堂上耐心细致地讲解知识点，并提供了很多实例和案例来帮助我们理解。同时，教师还鼓励我们积极参与课堂讨论，提出问题并与同学们共同解决。这种互动式的教学方式激发了学生的学习热情，提高了学习效果。
作业和实验是巩固学习成果与实践能力的重要环节。通过手动编写代码，解决实际问题，我深刻体会到了理论知识与实际应用的结合。作业和实验要求我们独立思考，并通过查阅资料和与同学交流来获取解决问题的方法和思路。这培养了我们的学习能力、解决问题的能力和团队合作能力。
在课上及课下组织方式方面，我认为多种教学手段的结合是有效的学习方式。教师通过课堂讲解、实例演示、小组讨论等形式来提供知识，并鼓励我们在自主学习的过程中探索和创新。同时，课后提供相关学习资料和习题，使我们能够有针对性地进行巩固和扩展学习。这样的教学方式既培养了我们的自学能力，也激发了学习的乐趣。
虽然在JAVA学习过程中我积累了一定的知识和经验，但我也意识到还有很多需要进一步学习和研究的地方。首先，在JAVA的高级特性和框架方面，如多线程编程、网络编程、Spring框架等，我只是初步了解，需要深入学习和实践。其次，代码优化和性能调优也是我需要进一步提升的方面，以提高程序的效率和稳定性。此外，对于软件工程的相关知识和项目管理方法，我也希望能够有更多的学习机会。
总之，通过JAVA的学习，我深入了解了面向对象的编程思想和JAVA编程的基本技能。同时，通过与教师、同学们的交流互动以及完成作业和实验，我不仅获得了知识和技能，也培养了自学能力、解决问题的能力和团队协作精神。对于教师、课程、作业、实验以及课上及课下组织方式等方面，我感到非常满意，并期待在未来的学习中持续进步和发展。