一、前言

总结三次题目集的知识点、题量、难度等情况

java的面向对象编程和c++有一定的区别，因此在最开始接触此类题目的时候不太适应，不过任何东西上手都要有一个过程，阶段性的总结可以学到更多的东西。

知识点

除了java基本语法的运用，大部分题目用到的还是一些基础的计算和逻辑判断，简单的题目无非就是为了熟悉java编程的一套方法和规则，像严格的类型匹配之类的。

在题目集二的7-5里面练习了无参和有参的变量构造方法。

像题目集二的7-7、7-8和题目集三的7-2这种综合运用的大题目，涉及到的知识点比较多，更多考量的是类之间的互相调用。

题量和难度

三次题目集的题量并不大，，题目集一都是很基础的计算判断和逻辑题，而题目集二中7-7与同个题目集中其他题目的难度相差较大，题目集三中7-2又与其他题目相差太大。

二、设计与分析

重点对题目的提交源码进行分析，可参考SourceMonitor的生成报表内容以及PowerDesigner的相应类图，要有相应的解释和心得

题目集一

这是接触java开始做的第一次作业，虽然题目难度很简单，基本是计算和类型判断的题目，甚至不需要分类，单纯使用选择语句就可以完成，但是因为不熟练，代码非常的生硬和简朴

import java.util.Scanner;
class Student{
    Scanner input = new Scanner(System.in);
    private String ID;
    private String Name;
    private int Chinesescore,Mathscore,Physicscore;
    int Sumscore;
    float Averagescore;
    public int getPhysicscore() {
        return Physicscore;
    }
    public void setPhysicscore(int physicscore) {
        this.Physicscore = physicscore;
    }
    public int getMathscore() {
        return Mathscore;
    }
    public void setMathscore(int mathscore) {
        this.Mathscore = mathscore;
    }
    public int getChinesescore() {
        return Chinesescore;
    }
    public void setChinesescore(int chinesescore) {
        this.Chinesescore = chinesescore;
    }
    public String getID() {
        return ID;
    }
    public void setID(String iD) {
        this.ID = iD;
    }
    public String getName() {
        return Name;
    }
    public void setName(String name) {
        this.Name = name;
    }
    public void getSumscore() {
        this.Sumscore = (getChinesescore()+getMathscore()+getPhysicscore());
    }
    public void getAveragescore(){
        this.Averagescore = (float)(Sumscore)/3;
    }
}
public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        Student []stu = new Student[5];
        for(int i = 0;i<5;i++) {
            stu[i] = new Student();
            stu[i].setID(input.next());
            stu[i].setName(input.next());
            stu[i].setChinesescore(input.nextInt());
            stu[i].setMathscore(input.nextInt());
            stu[i].setPhysicscore(input.nextInt());
            stu[i].getSumscore();
            stu[i].getAveragescore();
        }
        for(int i = 0;i<5;i++) {
            System.out.println(stu[i].getID()+" "+stu[i].getName()+" "+stu[i].Sumscore+" "+String.format("%.2f", stu[i].Averagescore));
        }
    }
}

这是第一次使用和引用类，给每一个变量都上了private，用get和set来进行赋值和取值（其实完全没有必要）

7-2

这个题目是上一个题目的plus版本，增加了乱序输入这一难点
先上类图

再上报表分析内容

这次与上一题的改进点就是将分数统计的方法也放到了特定的类里，Main类就比较简洁了,没有特殊的变量范围限定，也就没有使用private来封装变量。

成绩分为三部分，平时成绩、期末成绩和总成绩，于是每门课成绩都选择使用长度为3的数组来存储。

7-7

菜单计价程序是本套题目的重点和难点，需要重点分析。

某饭店提供4种菜，每种菜品的基础价格如下：
西红柿炒蛋 15
清炒土豆丝 12
麻婆豆腐 12
油淋生菜 9

设计点菜计价程序，根据输入的订单，计算并输出总价格。
订单由一条或多条点菜记录组成，每条记录一行，最后以"end"结束
每条点菜记录包含：菜名、份额两个信息。
份额可选项包括：1、2、3，分别代表小、中、大份）

不同份额菜价的计算方法：
小份菜的价格=菜品的基础价格。
中份菜的价格=菜品的基础价格1.5。
小份菜的价格=菜品的基础价格2。
如果计算出现小数，按四舍五入的规则进行处理。

参考以下类的模板进行设计：
菜品类：对应菜谱上一道菜的信息。
Dish {
String name;//菜品名称
int unit_price; //单价
int getPrice(int portion)//计算菜品价格的方法，输入参数是点菜的份额（输入数据只能是1/2/3，代表小/中/大份）
}

菜谱类：对应菜谱，包含饭店提供的所有菜的信息。
Menu {
Dish[] dishs ;//菜品数组，保存所有菜品信息
Dish searthDish(String dishName)//根据菜名在菜谱中查找菜品信息，返回Dish对象。
}

点菜记录类：保存订单上的一道菜品记录
Record {
Dish d;//菜品
int portion;//份额（1/2/3代表小/中/大份）
int getPrice()//计价，计算本条记录的价格
}

订单类：保存用户点的所有菜的信息。
Order {
Record[] records；//保存订单上每一道的记录
int getTotalPrice()//计算订单的总价
Record addARecord(String dishName,int portion)
//添加一条菜品信息到订单中。
}

输入格式:
每条点菜记录的格式：
菜名+空格（英文）+份额
注：份额可输入（1/2/3）， 1代表小份，2代表中份，3代表大份。
最后一条记录以“end”结束。

输出格式:
订单上所有菜品的总价（整数数值），每份菜
如果订单中包含不能识别的菜名，则在总价之前输出“** does not exist”，**是不能识别的菜名

因为本题题目已经将类分好给我们，只需要完善相应代码就好，大大降低了难度。先上代码的分析图。

题目所给的几个类中刚好是嵌套关系，而当时我没有学继承相关的代码，于是在一个类中添加需要嵌套的类的数组形式（其实更应该用集合方便动态记录数据），而相关的方法，比如计算单道菜的价格放在Record类里，而初始化和判断输入的合法放在menu类里，总价格的获取放在Order类中，各司其职。Main类只需要一个while循环不断输入就行了。

import java.util.Scanner;
public class Main{
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        Order ord = new Order();
        String name;
        int portion;
        int TotalPrice;
        name = input.next();
        while(name.compareTo("end") != 0) {
            portion = input.nextInt();
            ord.addARecord(name, portion);
            name = input.next(); 
        }
        TotalPrice = ord.getTotalPrice();
        System.out.println(TotalPrice);
    }
}
class Dish {
    String name;//菜品名称
    int unit_price; //单价
    int getPrice(int portion){
        int Price = 0;
        double multiple = 0;
        if(portion == 1) {
            multiple = 1;
        }
        else if(portion == 2) {
            multiple = 1.5;
        }
        else {
            multiple = 2;
        }
        Price = (Math.round((float)unit_price*(float)multiple));
        return Price;
    }
}
class Menu {
    Dish []dishs = new Dish[4];//菜品数组，保存所有菜品信息

    public void setMenu() {
        for(int i = 0;i<4;i++) {
            dishs[i] = new Dish();
        }
        dishs[0].name = "西红柿炒蛋";dishs[0].unit_price = 15;
        dishs[1].name = "清炒土豆丝";dishs[1].unit_price = 12;
        dishs[2].name = "麻婆豆腐";dishs[2].unit_price = 12;
        dishs[3].name = "油淋生菜";dishs[3].unit_price = 9;
    }

    Dish searthDish(String dishName) {
        int i;
        for(i = 0;i<4;i++) {
            if(dishName.compareTo(dishs[i].name) == 0) {
                break;
            }
        }
        if(i == 4) {
            System.out.println(dishName+" does not exist");
            return null;
        }
        //根据菜名在菜谱中查找菜品信息，返回Dish对象。
        return dishs[i];
    }
}
class Record {
    Dish d = new Dish();//菜品
    int portion;//份额（1/2/3代表小/中/大份）
    Menu menu = new Menu();
    int getPrice(){
        int price;
        menu.setMenu();
        d = menu.searthDish(d.name);
        if(d == null) {
            return 0;
        }
        price = d.getPrice(portion);
        return price;//计价，计算本条记录的价格        
    }
}
class Order {
    Record[] records = new Record[100];//保存订单上每一道的记录
    int count = 0;
    int TotalPrice = 0;
    int getTotalPrice(){
        for(int i = 0;i<count;i++) {
            TotalPrice += records[i].getPrice();
        }
        return TotalPrice;//计算订单的总价
    }
    Record addARecord(String dishName,int portion) {
        records[count] = new Record();
        records[count].d.name = dishName;
        records[count].portion = portion;
        count++;
        return records[count-1];
    }
    //添加一条菜品信息到订单中。
}

7-8

给定一个日期，判定是否为合法日期。如果合法，判断该年是否闰年，该日期是当年第几天、当月第几天、当周第几天、。
给定起始日期与结束日期，判定日期是否合法且结束日期是否早于起始日期。如果均合法，输出结束日期与起始日期之间的相差的天数、月数、念书。
输入格式:
第一行输入一个日期字符串，格式为"YYYY-MM-dd"
第二行输入两个日期字符串，中间使用空格隔开。分别代表开始日期与结束日期。

输出格式:
如果第一行日期字符串非法，输出自定义的错误信息。
如果第一行日期有效，输出相关信息，如果是闰年要输出是闰年。
如果第二行两个日期，只要有一个无效。就输出相关错误信息。
如果第二行两个日期有效且结束日期不早于开始日期，输出相关信息

从分析中就可以看出代码十分的复杂，拥有很多的循环和选择语句，不仅运行负载高，还非常容易出错。题目的难点在于输入的判断和各种复杂的计算。

import java.util.Scanner;
import java.time.LocalDate;
import java.time.temporal.ChronoUnit;


public class Main
{
    public static int []month_day = {31,28,31,30,31,30,31,31,30,31,30,31};
    public static void main(String[] args)
    {
        Scanner input  = new Scanner(System.in);
        String date = input.next();
        String start = input.next();
        String end = input.next();
        String date1 = number(date);
        String start1 = number(start);
        String end1 = number(end);
        int date2 = Integer.parseInt(date1);
        int start2 = Integer.parseInt(start1);
        int end2 = Integer.parseInt(end1);
        int dateDay = date2%100;
        int dateMonth = date2/100%100;
        int dateYear = date2/10000;
        int startDay = start2%100;
        int startMonth = start2/100%100;
        int startYear = start2/10000;
        int endDay = end2%100;
        int endMonth = end2/100%100;
        int endYear = end2/10000;
        int judgeR = rYear(dateYear);
        if(judgeR == 1)  month_day[1] = 29;
        int judgeLeg = judge_l(dateMonth,dateDay,date2);
        if(judgeLeg==0)
        {
            System.out.println(date+"无效!");
        }else {
            if(judgeR == 1) System.out.println(date+"是闰年.");
            int sum_day = daysOfYear(dateMonth, dateDay);
            LocalDate startDate = LocalDate.of(2000,01,02);
            LocalDate endDate = LocalDate.of(dateYear,dateMonth,dateDay);
            long days = Math.abs(ChronoUnit.DAYS.between(startDate, endDate))%7;
            if(days==0) days = 7;
            System.out.println(date + "是当年第" + sum_day + "天,当月第" + dateDay + "天,当周第" + days+"天.");
        }
        judgeR = rYear(startYear);
        if(judgeR == 0)  month_day[1] = 28;
        int judgeLegS = judge_l(startMonth,startDay,start2);
        judgeR = rYear(startYear);
        if(judgeR == 0)  month_day[1] = 28;
        if(judgeR == 1) month_day[1] = 29;
        int judgeLegE = judge_l(startMonth,startDay,end2);
        if(judgeLegS==0||judgeLegE==0)
            System.out.println(start + "或" + end + "中有不合法的日期.");
        else if(start2>end2)
        {
            System.out.println(end+"早于"+start+",不合法!");
        }
        else
        {
            int yearSub = endYear - startYear;
            int monthSub = endMonth - startMonth;
            LocalDate startDate = LocalDate.of(startYear,startMonth,startDay);
            LocalDate endDate = LocalDate.of(endYear,endMonth,endDay);
            long days = ChronoUnit.DAYS.between(startDate, endDate);
            System.out.print(end+"与"+start+"之间相差"+days+"天,所在月份相差"+monthSub+",所在年份相差"+yearSub+".");
        }
    }
    public static String number(String str) //字符串转化为数字
    {
        str=str.trim();
        String str2="";
        if(str != null && !"".equals(str))
        {
            for(int i=0;i<str.length();i++)
            {
                if(str.charAt(i)>=48 && str.charAt(i)<=57)
                {
                    str2+=str.charAt(i);
                }
            }
        }
        return str2;
    }
    public static int daysOfYear(int month,int day)//当年的第几天
    {
        int sum=0;
        for(int i=0;i<month-1;i++)
        {
            sum += month_day[i];
        }
        sum += day;
        return sum;
    }
    public static int rYear(int year)//判断闰年
    {
        int r = 0;
        if((0 == year % 4 && year % 100 != 0) || (0 == year % 400))
        {
            r = 1;
        }
        return r;
    }
    public static int judge_l(int month,int day,int whole)
    {
        int tmp = 0;
        if(whole<100000000&&whole>=10000000) {
            if (day >= 1 && day <= month_day[month - 1]) {
                return tmp = 1;
            } else {
                return tmp = 0;
            }
        }
        else return tmp;
    }
}

7-2 课程成绩统计程序-1

分数 65

作者蔡轲

单位南昌航空大学

某高校课程从性质上分为：必修课、选修课，从考核方式上分为：考试、考察。

考试的总成绩由平时成绩、期末成绩分别乘以权重值得出，比如平时成绩权重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.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:courseMes(str);
                    break;
            case 2:gradeMes(str);
                    break;
        }
    }
    public void courseMes(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 gradeMes(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{
                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 cs:listClass){
            if(cs.getClassId().equals(classId))
                return cs;
        }
        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 cs=listClass.get(i);
            ArrayList<ChooseCourse> stuCourseSelects=getClassSelects(cs.getClassId());
            if(stuCourseSelects.size()!=0){
                System.out.println(cs.getClassId()+" "+getAvgTotalScore(stuCourseSelects));
            }
            else if(stuCourseSelects.size()==0){
                System.out.println(cs.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 csId){
        ArrayList<ChooseCourse> choose =new ArrayList<>();
        for(ChooseCourse cos:listChooseCourse) {
            if (cos.student.getClsId().equals(csId))
                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 csId;
    public String getId(){
        return id;
    }
    public String getStuName(){
        return stuName;
    }
    public String getClsId(){
        return csId;
    }
    public Student(String csId,String id,String stuName) {
        this.csId=csId;
        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;
    }
}

7-3 面向对象编程(封装性)

分数 10

作者蒋辉

单位天津仁爱学院

Student类具体要求如下：
私有成员变量：学号(sid，String类型)，姓名(name，String类型)，年龄(age，int类型)，专业(major，String类型) 。
提供无参构造和有参构造方法。（注意：有参构造方法中需要对年龄大小进行判定）
普通成员方法：print()，输出格式为“学号：6020203100，姓名：王宝强，年龄：21，专业：计算机科学与技术”。
普通成员方法：提供setXxx和getXxx方法。（注意：setAge()方法中需要对年龄进行判定）
注意：
年龄age不大于0，则不进行赋值。
print()中的“：”和“，”为均为中文冒号和逗号。

public class Main{
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        //调用无参构造方法，并通过setter方法进行设值
        String sid1 = sc.next();
        String name1 = sc.next();
        int age1 = sc.nextInt();
        String major1 = sc.next();
        Student student1 = new Student();
        student1.setSid(sid1);
        student1.setName(name1);
        student1.setAge(age1);
        student1.setMajor(major1);
        //调用有参构造方法
        String sid2 = sc.next();
        String name2 = sc.next();
        int age2 = sc.nextInt();
        String major2 = sc.next();
        Student student2 = new Student(sid2, name2, age2, major2);
        //对学生student1和学生student2进行输出
        student1.print();
        student2.print();
    }
}

/* 请在这里填写答案 */

代码如下：

import java.util.*;
public class Main{
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String id1 = sc.next();
        String name1 = sc.next();
        int age1 = sc.nextInt();
        String major1 = sc.next();
        Student student1 = new Student();
        student1.setid(id1);
        student1.setName(name1);
        student1.setAge(age1);
        student1.setMajor(major1);
        //调用有参构造方法
        String id2 = sc.next();
        String name2 = sc.next();
        int age2 = sc.nextInt();
        String major2 = sc.next();
        Student student2 = new Student(id2, name2, age2, major2);
        //对学生student1和学生student2进行输出
        student1.print();
        student2.print();
    }
}

class Student{
    private String id;
    private String name;
    private int age;
    private String major;
    Student(){
        
    }
    Student(String id,String name,int age,String major){
        this.id = id;
        this.name = name;
            if(age < 0)
        {
            System.exit(0);
        }
        this.age = age;
        this.major = major;
    
    }
    public String getid() {
        return id;
    }
    public void setid(String id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        if(age < 0)
        {
            System.exit(0);
        }
        this.age = age;
    }
    public String getMajor() {
        return major;
    }
    public void setMajor(String major) {
        this.major = major;
    }
    public void print() {
        System.out.println("学号："+getid()+","+"姓名："+this.name+","+"年龄："+this.age+","+"专业："+this.major);
    }
}

7-4 判断两个日期的先后，计算间隔天数、周数

分数 15

作者吴光生

单位新余学院

从键盘输入两个日期，格式如：2022-06-18。判断两个日期的先后，并输出它们之间间隔的天数、周数（不足一周按0计算）。

预备知识：通过查询Java API文档，了解Scanner类中nextLine()等方法、String类中split()等方法、Integer类中parseInt()等方法的用法，了解LocalDate类中of()、isAfter()、isBefore()、until()等方法的使用规则，了解ChronoUnit类中DAYS、WEEKS、MONTHS等单位的用法。

输入格式:

输入两行，每行输入一个日期，日期格式如：2022-06-18

输出格式:

第一行输出：第一个日期比第二个日期更早（晚）
第二行输出：两个日期间隔XX天
第三行输出：两个日期间隔XX周

本题是对上一题目集日期类使用的简化版本，这次题目明确要求了使用日期类，用上了LocalDate和ChronoUnit两个类。

上分析图。

import java.time.LocalDate;
import java.time.temporal.ChronoUnit;
import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String s1 = sc.nextLine();
        String s2 = sc.nextLine();
        String [] dateStr1 = s1.split("-");
        String [] dateStr2 = s2.split("-");
        int year1 = Integer.parseInt( dateStr1[0] );
        int month1 = Integer.parseInt( dateStr1[1] );
        int day1 = Integer.parseInt( dateStr1[2] );
        int year2 = Integer.parseInt( dateStr2[0] );
        int month2 = Integer.parseInt( dateStr2[1] );
        int day2 = Integer.parseInt( dateStr2[2] );
        LocalDate date1 = LocalDate.of(year1, month1, day1);
        LocalDate date2 = LocalDate.of(year2, month2, day2);
        if( date1.isBefore(date2))
            System.out.println("第一个日期比第二个日期更早");
        else
            System.out.println("第一个日期比第二个日期更晚");
        
        long dayCount = date1.until(date2, ChronoUnit.DAYS);
        long weekCount = date1.until(date2, ChronoUnit.WEEKS);
        System.out.println("两个日期间隔" + Math.abs(dayCount) + "天" );
        System.out.println("两个日期间隔" + Math.abs(weekCount) + "周" );
        sc.close();
    }
}

总结

通过三次大作业，学会了java的基本知识，也逐渐学会了使用类和对象，但还是不熟练，要勤加练习，尤其第三次大作业题目的难度，也让我知道了自己的很多不足的地方，Java这门语言，不仅考验了逻辑思维能力还有用代码的表达能力，用最好的方式最好的思维写出最简洁的代码，这是很难的地方，还要多多学习Java这门语言，面对难题的时候要多思考，多练习，寻找最优解。

在这三次作业中，遇到了很多困难，也有很多严重的问题，最开始是语法，后来熟悉后思维方式还没有变通，还是总爱使用面向过程的方式，对Java没有更深的认知，所以在后面的练习中，要多用类和对象的方式，使用面向对象的程序设计，加强自己对Java的理解，这样才能更好的写出优秀的代码。

JZTXT

第一次博客作业