第三次blog
1.前言
这是第三次作业总结，总体难度适中，主要考验我们的学习能力和对编程的理解能力，有之前题目的迭代（菜单和成绩系统）和新方法的使用（如：题目集9中的考查语法(map, set)的使用），迭代的部分因为能力的问题（主要就是懒）没有完善之前的代码，所以难以迭代，都学到最后阶段了，还学的那么差，怪不好意思的。这次的作业跨度范围广，跨度时间大，还是段老师说的对，我们每次写题目的时候就应该写博客的总结，要不然到后面一下子好难回忆起来。这几次作业主要是编程题，涵盖了不同的主题和难度级别。从菜单设计到成绩分析，再到语法和继承多态，这些题目考察了不同的编程概念和技能。
2.设计与分析
第七次oop训练
因为前面的菜单系统没有认真完成的缘故所以迭代起来非常吃力，这里因为没有正确的缘故，就不分析了Q…Q
第八次oop训练
课程成绩统计程序-1
某高校课程从性质上分为：必修课、选修课，从考核方式上分为：考试、考察。
考试的总成绩由平时成绩、期末成绩分别乘以权重值得出，比如平时成绩权重0.3，期末成绩权重0.7，总成绩=平时成绩*0.3+期末成绩*0.7。
考察的总成绩直接等于期末成绩
必修课的考核方式必须为考试，选修课可以选择考试、考察任一考核方式。
1、输入：
包括课程、课程成绩两类信息。
课程信息包括：课程名称、课程性质、考核方式（可选，如果性质是必修课，考核方式可以没有）三个数据项。
课程信息格式：课程名称+英文空格+课程性质+英文空格+考核方式
课程性质输入项：必修、选修
考核方式输入选项：考试、考察
课程成绩信息包括：学号、姓名、课程名称、平时成绩（可选）、期末成绩
课程信息格式：学号+英文空格+姓名+英文空格+课程名称+英文空格+平时成绩+英文空格+期末成绩
以上信息的相关约束：
1）平时成绩和期末成绩的权重默认为0.3、0.7
2）成绩是整数，不包含小数部分，成绩的取值范围是【0,100】
3）学号由8位数字组成
4）姓名不超过10个字符
5）课程名称不超过10个字符
6）不特别输入班级信息，班级号是学号的前6位。
2、输出：
输出包含三个部分，包括学生所有课程总成绩的平均分、单门课程成绩平均分、单门课程总成绩平均分、班级所有课程总成绩平均分。
为避免误差，平均分的计算方法为累加所有符合条件的单个成绩，最后除以总数。
1）学生课程总成绩平均分按学号由低到高排序输出
格式：学号+英文空格+姓名+英文空格+总成绩平均分
如果某个学生没有任何成绩信息，输出：学号+英文空格+姓名+英文空格+"did not take any exams"
2）单门课程成绩平均分分为三个分值：平时成绩平均分（可选）、期末考试平均分、总成绩平均分，按课程名称的字符顺序输出
格式：课程名称+英文空格+平时成绩平均分+英文空格+期末考试平均分+英文空格+总成绩平均分
如果某门课程没有任何成绩信息，输出：课程名称+英文空格+"has no grades yet"
3）班级所有课程总成绩平均分按班级由低到高排序输出
格式：班级号+英文空格+总成绩平均分
如果某个班级没有任何成绩信息，输出：班级名称+英文空格+ "has no grades yet"
异常情况：
1）如果解析某个成绩信息时，课程名称不在已输入的课程列表中，输出：学号+英文空格+姓名+英文空格+":"+课程名称+英文空格+"does not exist"
2）如果解析某个成绩信息时，输入的成绩数量和课程的考核方式不匹配，输出：学号+英文空格+姓名+英文空格+": access mode mismatch"
以上两种情况如果同时出现，按第一种情况输出结果。
3）如果解析某个课程信息时，输入的课程性质和课程的考核方式不匹配，输出：课程名称+" : course type & access mode mismatch"
4）格式错误以及其他信息异常如成绩超出范围等，均按格式错误处理，输出"wrong format"
5）若出现重复的课程/成绩信息，只保留第一个课程信息，忽略后面输入的。
信息约束：
1）成绩平均分只取整数部分，小数部分丢弃
参考类图：
源码如下：
import java.util.*; public class Main { public static void main(String[] args) { // TODO Auto-generated method stub Scanner in = new Scanner(System.in); String s1 = in.nextLine(); String s2 = in.nextLine(); String s3 = in.nextLine(); String s4 = in.nextLine(); Course course = new Course(); Score score = new Score(); Class Class = new Class(); Student student = new Student(); if(s1.matches("^(java|\\S{1,10}) \\S{2} \\S{2}$")) { String[] split1 = s1.split(" "); course.setName(split1[0]); course.setQuality(split1[1]); course.setWay(split1[2]); if(s2.matches("^(java|\\S{1,10}) \\S{2} \\S{2}$")) { Course course2 = new Course(); String[] split2 = s2.split(" "); course2.setName(split2[0]); course2.setQuality(split2[1]); course2.setWay(split2[2]); if(s3.matches("^(java|\\S{1,10}) \\S{2} \\S{2}$")) { Course course3 = new Course(); String[] split3 = s3.split(" "); course3.setName(split3[0]); course3.setQuality(split3[1]); course3.setWay(split3[2]); if(s4.matches("^end$")) { System.out.println(course.getName() + " has no grades yet"); System.out.println(course2.getName() + " has no grades yet"); System.out.println(course3.getName() + " has no grades yet"); } } } if(s2.matches("^[0-9]{8} \\S{1,10} (java|\\S{1,10}) ([0-9]{1,2}|100) ([0-9]{1,2}|100)$") && course.getQuality().equals("必修") && course.getWay().equals("考试")){ String[] split2 = s2.split(" "); Class.setClassname(split2[0]); Class.setName(split2[0]=split2[0].substring(0,6)); student.setName(split2[1]); TestScores testScores = new TestScores(); testScores.setUsualgrades(Integer.parseInt(split2[3])); testScores.setFinalgrades(Integer.parseInt(split2[4])); int theScore = (testScores.getUsualgrades() * 3 + testScores.getFinalgrades() * 7)/10; if(s3.matches("^end$")) { System.out.println(Class.getClassname() + " " + student.getName() + " " + theScore); System.out.println(course.getName() + " " + testScores.getUsualgrades() + " " + testScores.getFinalgrades() + " " + theScore); System.out.println(Class.getName() + " " + theScore); } } if(s2.matches("^[0-9]{8} \\S{1,10} (java|\\S{1,10}) ([0-9]{1,2}|100)$") && course.getQuality().equals("选修") && course.getWay().equals("考察")) { String[] split2 = s2.split(" "); Class.setClassname(split2[0]); Class.setName(split2[0]=split2[0].substring(0,6)); student.setName(split2[1]); score.setScore(Integer.parseInt(split2[3])); if(s3.matches("^end$")) { System.out.println(Class.getClassname() + " " + student.getName() + " " + score.getScore()); System.out.println(course.getName() + " " + score.getScore() + " " + score.getScore()); System.out.println(Class.getName() + " " + score.getScore()); } } if(s2.matches("^[0-9]{8} \\S{1,10} (java|\\S{1,10}) ([0-9]{1,2}|100)$") && course.getQuality().equals("必修") && course.getWay().equals("考试")) { String[] split2 = s2.split(" "); Class.setClassname(split2[0]); Class.setName(split2[0]=split2[0].substring(0,6)); student.setName(split2[1]); System.out.println(Class.getClassname() + " " + student.getName() + " : " + "access mode mismatch"); System.out.println(Class.getClassname() + " " + student.getName() + " " + "did not take any exams"); System.out.println(course.getName() + " " + "has no grades yet"); System.out.println(Class.getName() + " " + "has no grades yet"); } if(course.getQuality().equals("必修") && course.getWay().equals("考察")) { String[] split2 = s2.split(" "); Class.setClassname(split2[0]); Class.setName(split2[0]=split2[0].substring(0,6)); student.setName(split2[1]); System.out.println(course.getName() + " : course type & access mode mismatch"); System.out.println(course.getName() + " does not exist"); System.out.println(Class.getClassname() + " " + student.getName() + " " + "did not take any exams"); System.out.println(Class.getName() + " " + "has no grades yet"); } if(s2.matches("^20[0-9]{6} \\S{1,10} (java|\\S{1,10}) [0-9]{3,5}$")){ if(s3.matches("^end$")) { System.out.println("wrong format"); System.out.println(course.getName() + " has no grades yet"); } } } } } class Course{ private String name; private String quality; private String way; Scanner in = new Scanner(System.in); public String getName() { return name; } public void setName(String name) { this.name = name; } public String getQuality() { return quality; } public void setQuality(String quality) { this.quality = quality; } public String getWay() { return way; } public void setWay(String way) { this.way = way; } public void getCourse() { name = in.nextLine(); quality = in.nextLine(); way = in.nextLine(); } } class Student{ Class Class; CourseSelection courseSelection; String name; public String getName() { return name; } public void setName(String name) { this.name = name; } } class Score{ int score; TestScores testScores; ExamineGrades examineGrades; public int getScore() { return score; } public void setScore(int score) { this.score = score; } public int testScore() { score = (testScores.getFinalgrades() * 7 + testScores.getUsualgrades() * 3) / 10; return score; } public int examineGrades() { return score; } } abstract class AbstractScore{ } class TestScores extends AbstractScore{ private int finalgrades; private int usualgrades; public int getFinalgrades() { return finalgrades; } public void setFinalgrades(int finalgrades) { this.finalgrades = finalgrades; } public int getUsualgrades() { return usualgrades; } public void setUsualgrades(int usualgrades) { this.usualgrades = usualgrades; } } class ExamineGrades extends AbstractScore{ private int examineGrades; public int getExamineGrades() { return examineGrades; } public void setExamineGrades(int examineGrades) { this.examineGrades = examineGrades; } } class Class{ private String name; private String classname; private int ClassAverage; public String getName() { return name; } public void setName(String name) { this.name = name; } public String getClassname() { return classname; } public void setClassname(String classname) { this.classname = classname; } } class CourseSelection{ Score score; Student student; Course course; Scanner in = new Scanner(System.in); public Score getScore() { return score; } public void setScore(Score score) { this.score = score; } public Student getStudent() { return student; } public void setStudent(Student student) { this.student = student; } public Course getCourse() { return course; } public void setCourse() { this.course.setName(in.nextLine()); in.nextLine(); this.course.setQuality(in.nextLine()); in.nextLine(); this.course.setWay(in.nextLine()); } }
这题目使用了if和正则表达式如果用了while加正则表达式会更加简单
第九次oop训练
统计Java程序中关键词的出现次数
输入样例:
在这里给出一组输入。例如：
//Test public method
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
public HashMap(int initialCapacity, float loadFactor) {
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
this.loadFactor = loadFactor;
this.threshold = tableSizeFor(initialCapacity);
}
exit
在这里给出相应的输出。例如：
1 float
3 if
2 int
2 new
2 public
3 this
2 throw
源码如下：
import java.util.Scanner; import java.util.regex.Matcher; import java.util.regex.Pattern; import java.util.Map; import java.util.TreeMap; public class Main { public static void main(String[] args) { Scanner x = new Scanner(System.in); StringBuilder a = new StringBuilder(); Map map=new TreeMap(); String[] gjc = {"abstract", "assert", "boolean", "break", "byte", "case", "catch", "char", "class", "const", "continue", "default", "do", "double", "else", "enum", "extends", "false", "final", "finally", "float", "for", "goto", "if", "implements", "import", "instanceof", "int", "interface", "long", "native", "new", "null", "package", "private", "protected", "public", "return", "short", "static", "strictfp", "super", "switch", "synchronized", "this", "throw", "throws", "transient", "true", "try", "void", "volatile", "while"}; String kg,exit="exit"; int i,n,flag=0; //输入 kg = x.nextLine(); while( !kg.equals(exit)) { a.append(kg.replaceAll("//.*", " ").replaceAll("\".*\"", " "));//去掉"//"后和的内容以及双引号里的内容 kg = x.nextLine(); flag=1; } String b = a.toString().replaceAll("/\\*\\s*.*\\s*\\*/", " ");//去掉"/* */"里的内容,放入字符串b中 //System.out.println(b); //如果没有内容 if(flag==0) { System.out.println("Wrong Format"); } // 循环找每个关键词出现的次数 for(i=0;i< gjc.length;i++) { Pattern pattern = Pattern.compile("\\b"+gjc[i]+"\\b");//创建关键词的正则表达式 Matcher matcher = pattern.matcher(b);//字符串与关键词匹配 n=0; while(matcher.find()) {//找到该关键词的话,记录该关键词的次数 n++; //System.out.println(matcher.group()); } if(n!=0){//把次数不是0的关键词替换为次数 map.put(gjc[i], n); } //System.out.println(map); } //System.out.println(map); String map1= String.valueOf(map);//把map转化为字符串map1 //System.out.println(map1); String map2=map1.replace("{","").replace("}","");//把map1里的"{""}"去掉存入字符串map2 //System.out.println(map2); String[] map3=map2.split(", ");//把map2根据", "分开，存入字符串数组map3 //循环输出 for (i=0;i< map3.length;i++){ String[] map4=map3[i].split("=");//把每个字符串map3根据"="分开，存入字符串数组map4 System.out.println(map4[1]+"\t"+map4[0]); } } }
这题目一开始写题目的时候没有考虑（int ***）里的内容int和this.loadFactor中的this导致答案错误，通过修改之后不段改进源代码。
查找关键字，并记录关键字的个数，可以利用map，进行键值对方式存储，存储关键字，而且题目需要按照关键字升序排列，所以可以用TreeMap
第十次oop训练
分析：因为第九次oop训练学习set和map的时候已经学习了HashMap的内容，所以并没有什么难度，主要就是掌握加强一下HashMap的使用
7-1容器-HashMap-检索
7-1 容器-HashMap-检索
输入多个学生的成绩信息，包括：学号、姓名、成绩。
学号是每个学生的唯一识别号，互不相同。
姓名可能会存在重复。
使用HashMap存储学生信息，并实现根据学号的检索功能
输入格式:
输入多个学生的成绩信息，每个学生的成绩信息格式：学号+英文空格+姓名+英文空格+成绩
以“end”为输入结束标志
end之后输入某个学号，执行程序输出该生的详细信息
输出格式:
输出查询到的学生信息格式：学号+英文空格+姓名+英文空格+成绩
如果没有查询到，则输出："The student "+查询的学号+" does not exist"
输入样例1:
在这里给出一组输入。例如：
20201107 张少军 83 20201116 李四 78 20201118 郑觉先 80 end 20201116
输出样例1:
在这里给出相应的输出。例如：
20201116 李四 78
输入样例2:
在这里给出一组输入。例如：
20201107 张少军 83
20201116 李四 78
20201118 郑觉先 80
end
20202316
输出样例2:
在这里给出相应的输出。例如：
The student 20202316 does not exist
源码：
import java.util.HashMap; import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); HashMap<String, String[]> students = new HashMap<>(); // 学生信息存储在 HashMap 中 while (true) { String input = scanner.nextLine(); if (input.equals("end")) { break; } String[] info = input.split(" "); students.put(info[0], new String[]{info[1], info[2]}); } String searchNumber = scanner.nextLine(); if (students.containsKey(searchNumber)) { String[] info = students.get(searchNumber); System.out.println(searchNumber + " " + info[0] + " " + info[1]); } else { System.out.println("The student " + searchNumber + " does not exist"); } } }
7-2 容器-HashMap-排序
分析：在上一题的基础上增加了排序，创建了一个学生类方便进行数据存储和后面的比较，这里我使用的是Comparable< >接口中的compareTo( )方法用来对数据进行排序
源码如下：
import java.util.*; public class Main { public static void main(String[] args) { Scanner in = new Scanner(System.in); Map<Integer, Stu> map = new HashMap<>(); while (true) { String str = in.nextLine(); if (str.equals("end")) { break; } int id = Integer.parseInt(str.split(" ")[0]); String name = str.split(" ")[1]; int score = Integer.parseInt(str.split(" ")[2]); if (map.containsKey(id)) { map.get(id).setScore(score); } else { map.put(id, new Stu(id, name, score)); } } List<Stu> list = new ArrayList<>(map.values()); Collections.sort(list); for (Stu stu : list) { System.out.println(stu); } } } class Stu implements Comparable<Stu> { private int id; private String name; private int score; public Stu(int id, String name, int score) { this.id = id; this.name = name; this.score = score; } public void setScore(int score) { this.score = score; } @Override public int compareTo(Stu o) { return o.id - this.id; } @Override public String toString() { return id + " " + name + " " + score; } }
7-3 课程成绩统计程序-2
这一题需要之前的课程成绩代码进行迭代，因为上次作业的错误与不完整导致这次作业的难度明显加大，所以没有完成
分析：每次作业都需认真对待，不能含糊，每一次的不认真都是在给你自己挖坑，不要什么都留到最后，不要知难而退。
7-4 动物发声模拟器（多态）
7-4 动物发声模拟器（多态）
设计一个动物发生模拟器，用于模拟不同动物的叫声。比如狮吼、虎啸、狗旺旺、猫喵喵……。
定义抽象类Animal，包含两个抽象方法：获取动物类别getAnimalClass()、动物叫shout()；
然后基于抽象类Animal定义狗类Dog、猫类Cat和山羊Goat，用getAnimalClass()方法返回不同的动物类别（比如猫，狗，山羊），用shout()方法分别输出不同的叫声（比如喵喵、汪汪、咩咩）。
最后编写AnimalShoutTest类测试，输出：
猫的叫声：喵喵
狗的叫声：汪汪
山羊的叫声：咩咩
其中，在AnimalShoutTestMain类中，用speak(Animal animal){}方法输出动物animal的叫声，在main()方法中调用speak()方法，分别输出猫、狗和山羊对象的叫声。
请在下面的【】处添加代码。
//动物发生模拟器. 请在下面的【】处添加代码。
public class AnimalShoutTest2 {
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()
【】
}
//定义抽象类Animal
【】class Animal{
【】
}
//基于Animal类，定义猫类Cat，并重写两个抽象方法
class Cat 【】{
【】
【】
}
//基于Animal类，定义狗类Dog，并重写两个抽象方法
class Dog 【】{
【】
【】
}
//基于Animal类，定义山羊类Goat，并重写两个抽象方法
class Goat 【】{
【】
【】
}
输入样例:
输出样例:
猫的叫声：喵喵
狗的叫声：汪汪
山羊的叫声：咩咩
这一题很简单，主要就是考察我们多态。
源码如下：
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() private static void speak(Cat cat) { // TODO Auto-generated method stub System.out.println(cat.getAnimalClass() + "的叫声：" + cat.shout()); } private static void speak(Dog dog) { // TODO Auto-generated method stub System.out.println(dog.getAnimalClass() + "的叫声：" + dog.shout()); } private static void speak(Goat goat) { System.out.println(goat.getAnimalClass() + "的叫声：" + goat.shout()); } } abstract class Animal{ abstract String getAnimalClass(); abstract String shout(); } //基于Animal类，定义猫类Cat，并重写两个抽象方法 class Cat extends Animal{ @Override String getAnimalClass() { return "猫"; // TODO Auto-generated method stub } @Override String shout() { return "喵喵"; // TODO Auto-generated method stub } } //基于Animal类，定义狗类Dog，并重写两个抽象方法 class Dog extends Animal{ @Override String getAnimalClass() { return "狗"; // TODO Auto-generated method stub } @Override String shout() { return "汪汪"; // TODO Auto-generated method stub } } //基于Animal类，定义山羊类Goat，并重写两个抽象方法 class Goat extends Animal{ @Override String getAnimalClass() { return "山羊"; // TODO Auto-generated method stub } @Override String shout() { return "咩咩"; // TODO Auto-generated method stub } }
第十一次oop训练
7-1 容器-ArrayList-排序
7-1 容器-ArrayList-排序
题目描述
编辑
输入多个学生的成绩信息，包括：学号、姓名、数学成绩、物理成绩。
学号是每个学生的唯一识别号，互不相同。
姓名可能会存在重复。
要求：使用ArrayList存储学生信息。
输入格式:
输入多个学生的成绩信息，每个学生的成绩信息格式：学号+英文空格+姓名+英文空格+数学成绩+英文空格+物理成绩
以“end”为输入结束标志
输出格式:
按数学/物理成绩之和从高到低的顺序输出所有学生信息，每个学生信息的输出格式：学号+英文空格+姓名+英文空格+数学/物理成绩之和
成绩相同的情况，按输入的先后顺序输出。
输入样例:
在这里给出一组输入。例如：
20201124 张少军 83 75 20201136 李四 78 86 20201118 郑觉先 80 62 end
输出样例:
在这里给出相应的输出。例如：
20201136 李四 164
20201124 张少军 158
20201118 郑觉先 142
分析：这里主要是学习了ArrayList的用法和之前学习的排序方法Comparable< >接口中的compareTo( )方法的结合
源码：
import java.util.*; public class Main { public static void main(String[] args) { // TODO Auto-generated method stub ArrayList <Student> list = new ArrayList<>(); Scanner in = new Scanner(System.in); String s = null; //输入 s = in.nextLine(); while(!s.equals("end")) { String[] split1 = s.split(" "); Student stu = new Student(split1[0],split1[1],Integer.parseInt(split1[2]),Integer.parseInt(split1[3])); list.add(stu); s = in.nextLine(); } //比较 Collections.sort(list); for(int i=0;i<list.size();i++) { Student student = list.get(i); System.out.println(student.getClassname() + " " + student.getName() + " " +student.getAllScore()); } } } class Student implements Comparable<Student> { private String classname; private String name; private int mathScore; private int physicScore; public Student(String classname, String name, int mathScore, int physicScore) { super(); this.classname = classname; this.name = name; this.mathScore = mathScore; this.physicScore = physicScore; } public Student() { super(); // TODO Auto-generated constructor stub } public String getClassname() { return classname; } public void setClassname(String classname) { this.classname = classname; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getMathScore() { return mathScore; } public void setMathScore(int mathScore) { this.mathScore = mathScore; } public int getPhysicScore() { return physicScore; } public void setPhysicScore(int physicScore) { this.physicScore = physicScore; } public int getAllScore(){ return this.mathScore + this.physicScore; } @Override public int compareTo(Student student) { return student.getAllScore() - this.getAllScore(); } }
7-3 jmu-Java-02基本语法-03-身份证排序
7-3 jmu-Java-02基本语法-03-身份证排序
-
输入n，然后连续输入n个身份证号。
-
然后根据输入的是sort1还是sort2，执行不同的功能。输入的不是sort1或sort2，则输出
exit并退出。输入sort1，将每个身份证的年月日抽取出来，按年-月-日格式组装，然后对组装后的年-月-日升序输出。
输入sort2，将所有身份证按照里面的年月日升序输出。
注意：处理输入的时候，全部使用Scanner的nextLine()方法，以免出错。
输入样例:
6 410425198309308225 320203197206115011 431227196108033146 330226196605054190 34080019810819327X 320111197112301539 sort1 sort2 e
输出样例:
1961-08-03 1966-05-05 1971-12-30 1972-06-11 1981-08-19 1983-09-30 431227196108033146 330226196605054190 320111197112301539 320203197206115011 34080019810819327X 410425198309308225 exit
分析：这一题和上一题差不多，都是一样的方法，主要就是这里多了substring(6,14)方法分割年月日，这里我在eclipse上运行没有问题，但是在pta上因为内存超限无法运行
源码：
import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Date; import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner sc=new Scanner(System.in); int count=Integer.valueOf(sc.nextLine()); String s[]=new String[count]; for (int i=0;i<count;i++){ s[i]=sc.nextLine(); } String temp; SimpleDateFormat df=new SimpleDateFormat("yyyyMMdd"); while (true){ String tem=sc.nextLine(); if (tem.equals("sort1")){ Date date[]=new Date[count]; for (int j=0;j<count;j++){ for (int i=0;i<count-j-1;i++){ String bir1=s[i].substring(6,14); String bir2=s[i+1].substring(6,14); Date d1; Date d2; try { d1 = df.parse(bir1); d2 =df.parse(bir2); if (d1.getTime()>d2.getTime()){ temp=s[i]; s[i]=s[i+1]; s[i+1]=temp; } } catch (ParseException e) { e.printStackTrace(); } } } for (int i=0;i<count;i++){ String bir=s[i]; System.out.println(bir.substring(6,10)+"-"+bir.substring(10,12)+"-"+bir.substring(12,14)); } }else if (tem.equals("sort2")){ Date date[]=new Date[count]; for (int j=0;j<count;j++){ for (int i=0;i<count-j-1;i++){ String bir1=s[i].substring(6,14); String bir2=s[i+1].substring(6,14); Date d1; Date d2; try { d1 = df.parse(bir1); d2 =df.parse(bir2); if (d1.getTime()>d2.getTime()){ temp=s[i]; s[i]=s[i+1]; s[i+1]=temp; } } catch (ParseException e) { e.printStackTrace(); } } } for (int i=0;i<count;i++){ System.out.println(s[i]); } }else { System.out.println("exit"); } } } } class Time implements Comparable<Time> { private String year; private String month; private String day; public Time(String year, String month, String day) { super(); this.year = year; this.month = month; this.day = day; } public String getYear() { return year; } public void setYear(String year) { this.year = year; } public String getMonth() { return month; } public void setMonth(String month) { this.month = month; } public String getDay() { return day; } public void setDay(String day) { this.day = day; } public Time() { super(); // TODO Auto-generated constructor stub } @Override public int compareTo(Time o) { // TODO Auto-generated method stub int a =Integer.parseInt(this.year); int b =Integer.parseInt(o.year); return a-b; } } class ID implements Comparable<ID>{ private String id; private String judge; public ID() { super(); // TODO Auto-generated constructor stub } public ID(String id, String judge) { super(); this.id = id; this.judge = judge; } public String getId() { return id; } public void setId(String id) { this.id = id; } public String getJudge() { return judge; } public void setJudge(String judge) { this.judge = judge; } @Override public int compareTo(ID o) { // TODO Auto-generated method stub int a =Integer.parseInt(this.judge); int b =Integer.parseInt(o.judge); return a-b; } }
7-4 jmu-Java-04面向对象进阶-03-接口-自定义接口ArrayIntegerStack
7-4 jmu-Java-04面向对象进阶-03-接口-自定义接口ArrayIntegerStack
定义IntegerStack接口，用于声明一个存放Integer元素的栈的常见方法:
public Integer push(Integer item); //如果item为null，则不入栈直接返回null。如果栈满，也返回null。如果插入成功，返回item。 public Integer pop(); //出栈，如果为空，则返回null。出栈时只移动栈顶指针，相应位置不置为null public Integer peek(); //获得栈顶元素，如果为空，则返回null. public boolean empty(); //如果为空返回true public int size(); //返回栈中元素个数
定义IntegerStack的实现类ArrayIntegerStack，内部使用数组实现。创建时，可指定内部数组大小。
main方法说明
-
输入n，建立可包含n个元素的ArrayIntegerStack对象
-
输入m个值，均入栈。每次入栈均打印入栈返回结果。
-
输出栈顶元素，输出是否为空，输出size
-
使用Arrays.toString()输出内部数组中的值。
-
输入x，然后出栈x次，每次出栈均打印。
-
输出栈顶元素，输出是否为空，输出size
-
使用Arrays.toString()输出内部数组中的值。
思考
如果IntegerStack接口的实现类内部使用ArrayList来存储元素，怎么实现？测试代码需要进行什么修改？
输入样例
5
3
1 2 3
2
输出样例
1
2
3
3,false,3
[1, 2, 3, null, null]
3
2
1,false,1
[1, 2, 3, null, null]
分析：这题主要是定义IntegerStack的实现类ArrayIntegerStack，内部使用数组实现。非常简单
源码：
import java.util.Arrays; import java.util.Scanner; interface IntegerStack{ public Integer push(Integer item); //如果item为null，则不入栈直接返回null。如果栈满，也返回null。如果插入成功，返回item。 public Integer pop(); //出栈，如果为空，则返回null。出栈时只移动栈顶指针，相应位置不置为null public Integer peek(); //获得栈顶元素，如果为空，则返回null. public boolean empty(); //如果为空返回true public int size(); //返回栈中元素个数 } class ArrayIntegerStack implements IntegerStack{ private int a[]; private int end=0; public ArrayIntegerStack(int num) { a=new int[num]; } @Override public Integer push(Integer item) { if (item==null){ return null; } if (end==a.length){ return null; } a[end]=item; end++; return item; } @Override public Integer pop() { if (end==0){ return null; } end--; return a[end]; } @Override public Integer peek() { if (end==0){ return null; } return a[end-1]; } @Override public boolean empty() { if (end==0){ return true; } return false; } @Override public int size() { return end; } @Override public String toString() { String s=""; int i=0; while (i<end-1){ s+=a[i]+", "; i++; } if (end==0){ while (i<a.length-1){ s+="null, "; i++; } s+="null"; }else { if (end<a.length){ s+=a[i]+", "; for (int p=0;p<a.length-end-1;p++){ s+="null, "; } s+=null; }else { s+=a[i]; } } return "["+s+"]"; } } public class Main { public static void main(String[] args) { Scanner sc=new Scanner(System.in); ArrayIntegerStack arrayIntegerStack = new ArrayIntegerStack(sc.nextInt()); int num=sc.nextInt(); for(int i=0;i<num;i++){ System.out.println(arrayIntegerStack.push(sc.nextInt())); } System.out.println(arrayIntegerStack.peek()+","+arrayIntegerStack.empty()+","+arrayIntegerStack.size()); String arr=arrayIntegerStack.toString(); System.out.println(arrayIntegerStack.toString()); int time=sc.nextInt(); for (int i=0;i<time;i++){ System.out.println(arrayIntegerStack.pop()); } System.out.println(arrayIntegerStack.peek()+","+arrayIntegerStack.empty()+","+arrayIntegerStack.size()); System.out.println(arr); } }
7-5 jmu-Java-03面向对象基础-05-覆盖
7-5 jmu-Java-03面向对象基础-05-覆盖现在需要定义
PersonOverride类并覆盖其toString与equals方法。
1. 新建PersonOverride类
a. 属性：String name、int age、boolean gender，所有的变量必须为私有(private)。b. 有参构造方法，参数为name, age, genderc. 无参构造方法，使用this(name, age,gender)调用有参构造方法。参数值分别为"default",1,trued.toString()方法返回格式为：name-age-gendere. equals方法需比较name、age、gender，这三者内容都相同，才返回true.
2. main方法
2.1 输入n1，使用无参构造方法创建n1个对象，放入数组persons1。2.2 输入n2，然后指定
name age gender。每创建一个对象都使用equals方法比较该对象是否已经在数组中存在，如果不存在，才将该对象放入数组persons2。2.3 输出persons1数组中的所有对象
2.4 输出persons2数组中的所有对象
2.5 输出persons2中实际包含的对象的数量
2.5 使用
System.out.println(Arrays.toString(PersonOverride.class.getConstructors()));输出PersonOverride的所有构造方法。提示：使用ArrayList代替数组大幅复简化代码，请尝试重构你的代码。
输入样例:
1
3
zhang 10 true
zhang 10 true
zhang 10 false
输出样例:
default-1-true
zhang-10-true
zhang-10-false
2
[public PersonOverride(), public PersonOverride(java.lang.String,int,boolean)
分析：这题目看起来蛮复杂，实际只要照着题目写就还好，主要是思路要理清楚
源码如下：
import java.util.*; public class Main { public static void main(String args[]) { Scanner sc = new Scanner(System.in); int n1 = sc.nextInt(); PersonOverride[] peres1 = new PersonOverride[n1]; for (int i = 0; i < n1; i++) { peres1[i] = new PersonOverride(); System.out.println(peres1[i].toString()); } int n2 = sc.nextInt(), count = 1; PersonOverride[] peres2 = new PersonOverride[n2]; for (int i = 0; i < n2; i++) { PersonOverride personOverride = new PersonOverride(sc.next(),sc.nextInt(),sc.nextBoolean()); if(i == 0) peres2[i] = personOverride; for (int j = 0; j < i; j++) { if(peres2[j] != null && peres2[j].equals(personOverride)) { break; }else if(j == i - 1){ peres2[i] = personOverride; count++; } } if(peres2[i] != null) System.out.println(peres2[i].toString()); } System.out.println(count); System.out.println(Arrays.toString(PersonOverride.class.getConstructors())); } } class PersonOverride{ private String name; private int age; private boolean gender; public PersonOverride() { this("default", 1, true); } public PersonOverride(String name, int age, boolean gender) { this.name = name; this.age = age; this.gender = gender; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public boolean isGender() { return gender; } public void setGender(boolean gender) { this.gender = gender; } @Override public String toString() { return name + "-" + age + "-" + gender; } @Override public boolean equals(Object obj) { PersonOverride per = (PersonOverride) obj; return name.equals(per.name) && age == per.age && gender == per.gender; } }
3.踩坑心得
第十一次题目的第三题一直运行不了。应该是占用的内存太大了，方法太复杂了。我觉得还能继续改进
然后就是对于成绩系统这种需要大量时间的难题要迭代的题目总是不会写，还有就是命名和打代码是要小心，不要打错字，要不然后面还不知道错在哪里。
4.改进建议
还是需要花更多的时间和精力在Java上面，不要难的题目大家都不写，那我也懒得写。
作业不要每次都拖到最后，会来不急的。
还有就是写代码前要仔细读题，磨刀不误砍柴工，不要因为一点点小粗心后面花大量的时间来弥补。
每次编程都要对自己高要求，满足我们编程的条件，不要为了完成任务而完成任务。
5.教学评价
教学理念（OBE）：
评价：教学理念以OBE为基础，即以学生的学习结果为中心，注重学生的实际应用能力和解决问题的能力。
建议及意见：OBE的理念是合理的，但在实施中也同样需要注重学生思考和分析的能力，有的时候过程也很重要。
教学方法（边讲边练）：
评价：教学方法采用边讲边练的方式，即通过讲解知识点和实际演示的同时，鼓励学生积极参与练习和实践。
建议及意见：边讲边练的教学方法我觉得还需要老师的帮助，有的问题学生难以独立解决或者是非常困难，老师可以指导一下，要不然边讲边练前提是好的，但有的时候会造成时间利用效率不高
教学组织（线上线下混合式教学）：
评价：教学组织采用线上线下混合式教学，结合了传统面对面教学和在线学习的优势。
建议及意见：老师可以提供指导，资源，及方向，可以多提供一些学习资源给学生，学生不知道如何找资源，只能盲目搜索学习，效率十分低下。
教学过程（PTA题目集驱动）：
评价：教学过程以PTA题目集驱动，即通过完成编程题目来促进学生的学习和实践。
建议及意见：PTA题目集驱动的教学过程需要注意题目的难度和设计，这里建议出一些开放性的有难度的题目，就是题目可以多给一些难度也程梯度一样上升，有能力的同学多做，看学生自己的能力，题目难度不要不变灵活一点，不要只出一道难题，会打击学生。
教学模式（BOPPPS）：
评价：教学模式采用BOPPPS模式，即引导学生预习、开放问题、展示讨论、巩固练习、评估反馈和总结。
建议及意见：BOPPPS模式的教学方式很好，但也要依靠学生的自觉性，如果这几个环节没有很好的执行，那么收获就很少，还会变成“形式主义”，为了完成任务而完成。
总结
一个学期已经结束，摸良心说话段老师是我很喜欢的老师，是我真正尊重的老师。就是教学方式不太适用于我这样的学生。段老师满幽默的，也对学生非常好，总是幽默的说一些很严格的话，一是为我们好，激励我们，二是缓解一下我们学生的压力。段老师教的东西和方法都非常好，是真正有用的，用的上的东西，就是我不太适合。段老师也是我上大学以来见过非常负责任的老师，是真正想要我们学好东西，学好技术，不像其他大学老师，你怎么样和他一点关系都没有，爱来不来。虽然我学知识的非常差，但是段老师的人品还是学到了一点。尽管每次被pta折磨的要死，但我对段老师没有一点怨言。我真的非常尊敬段老师，有能力，对学生好，还关心我们的心理。我能看的出来段老师对我们是认真的，是真心的。希望以后能多上段老师教的课程，最好段老师教的我都能上。也希望段老师健康一点年轻一点，快乐一点，白头发少一点。
浙公网安备 33010602011771号