首页 > 其他分享> > 题目集1~3的总结性Blog

题目集1~3的总结性Blog

2022-04-10 00:02:01 作者：互联网

（1）前言

知识点

基础知识：

java中的输入输出
基本运算符
条件语句
基本数据类型
循环语句
数组（一维，二维）等等

2 java面向对象：

类和对象
对象交互等

3 题量

题目集1：9题
题目集2：3题
题目集3：3题

4 难度分析

Easy：
- 题目集（1）：7-1 7-2 7-3 7-5 7-8 7-9
- 题目集（2）：7-1 7-3

Medium：
- 题目集（1）：7-4 7-6 7-7
- 题目集（2）：7-2

Hard：

题目集（3）：7-1 7-2 7-3 7-4

************************************************************************************************************************************************************************************************************************************************************************************************

（2）设计与分析

题目集2：7-2

7-2 串口字符解析 (50 分)

RS232是串口常用的通信协议，在异步通信模式下，串口可以一次发送5~8位数据，收发双方之间没有数据发送时线路维持高电平，相当于接收方持续收到数据“1”（称为空闲位），发送方有数据发送时，会在有效数据（5~8位，具体位数由通信双方提前设置）前加上1位起始位“0”，在有效数据之后加上1位可选的奇偶校验位和1位结束位“1”。请编写程序，模拟串口接收处理程序，注：假定有效数据是8位，奇偶校验位采用奇校验。

输入格式:

由0、1组成的二进制数据流。例如：11110111010111111001001101111111011111111101111

输出格式:

过滤掉空闲、起始、结束以及奇偶校验位之后的数据，数据之前加上序号和英文冒号。
如有多个数据，每个数据单独一行显示。
若数据不足11位或者输入数据全1没有起始位，则输出"null data"，
若某个数据的结束符不为1，则输出“validate error”。
若某个数据奇偶校验错误，则输出“parity check error”。
若数据结束符和奇偶校验均不合格，输出“validate error”。
如：11011或11111111111111111。
例如：
1:11101011
2:01001101
3:validate error

1. 7-2源码：

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        String ch=in.nextLine();
        if(ch.length()<11)
        {
            System.out.println("null data");     //判断是否字符串长度不符合，直接输出错误
        }
        boolean flag=false;
        for(int i=0;i<ch.length();i++)
        {
            if(ch.charAt(i)=='0')
            {
                flag=true;
            }
        }
        if(!flag){
            System.out.println("null data");     //若没有起始符0，则直接输出错误，并终止程序
            System.exit(0);
        }
        int n=0;
        for(int i=0;i<ch.length();i++){
            if(ch.charAt(i)!='0'){
                continue;
            }
            else{
                if(ch.charAt(i+10)=='1'){
                    int count=0;
                    for(int j=i+1;j<i+10;j++){
                        if(ch.charAt(j)=='1')
                            count++;
                    }
                    if(count%2!=0){
                        n++;
                        System.out.print(n+":");
                        for(int j=i+1;j<i+9;j++){
                            System.out.print(ch.charAt(j));      //输出最后正确结果
                        }
                        System.out.print("\n");
                    }
                    else{
                        n++;
                        System.out.println(n+":parity check error");   //数据奇偶校验错误
                    }
                }
                else{
                    n++;
                    System.out.println(n+":validate error");//数据结束符和奇偶校验均不合格或数据的结束符不为1
                }
                i+=10;
            }
        }
    }
}

2.我的心得：这道题本身难度并不大，我给的定位在Medium，主要是需要看清楚题目的要求，考虑到所有情况（这道题目有一些坑，部分测试点不好过），尽可能去思考还有哪几种可能出现的情况。

题目集3：7-1

7-1 用类解一元二次方程式 (10 分)

定义一个代表一元二次方程ax2+bx+c=0的类QuadraticEquation，其属性为三个系数a、b、c（均为私有属性），类中定义的方法参考main方法中的代码。main方法源码：

略

注意：须提交完整源码，包括Main类。

输入格式:

在一行中输入a、b、c的值，可以用一个或多个空格或回车符分开。

输出格式:

当输入非法时，输出“Wrong Format”
当有一个实根时，输出（2行）：

a=值,b=值,c=值:
The root is 值（保留两位小数）

当有两个实根时，输出（2行）：

a=值,b=值,c=值:
The roots are 值1 and 值2（均保留两位小数）

1.类图

2.7-1源码

import java.util.Scanner;

public class Main {
    public static void main(String[] args){
        Scanner input = new Scanner(System.in);

        double a = Double.parseDouble(input.next());
        double b = Double.parseDouble(input.next());
        double c = Double.parseDouble(input.next());

        if(a == 0){
            System.out.println("Wrong Format");                //不是二元一次方程进行错误判断
            System.exit(0);
        }

        //create a QuadraticEquation object
        QuadraticEquation equation = new QuadraticEquation(a, b, c);
        //get value of b * b - 4 * a * c
        double discriminant = equation.getDiscriminant();

        System.out.println("a=" + equation.getA() +
                ",b=" + equation.getB() +
                ",c=" + equation.getC()+":");

        if (discriminant < 0) {
            System.out.println("The equation has no roots.");
        }
        else if (discriminant == 0)
        {
            System.out.println("The root is " +
               String.format("%.2f", equation.getRoot1()));      //输出第一个解
        }
        else // (discriminant >= 0)
        {
            System.out.println("The roots are " +
                    String.format("%.2f", equation.getRoot1())
                    + " and " +  String.format("%.2f", equation.getRoot2()));         //输出第二个解
        }
    }
}

class QuadraticEquation{
    //your code
    private double a;
    private double b;
    private double c;
    private double discriminant;

    public QuadraticEquation(double a,double b,double c) {
        this.a = a;
        this.b = b;
        this.c = c;
        this.discriminant = discriminant;
    }

    public double getA() {
        return a;
    }

    public double getB() {
        return b;
    }

    public double getC() {
        return c;
    }

    public double getDiscriminant(){
        discriminant = b * b - 4 * a * c;
        return discriminant;
    }
    public double getRoot1(){
        return (-b+Math.sqrt(discriminant))/(2*a);     
    }
    public double getRoot2(){
        return (-b-Math.sqrt(discriminant))/(2*a);
    }
}

2.我的心得：这道题我给它的难度定位也是处于Medium，最主要还是之前在C语言的学习过程做过二元一次方程，并且会比这个更难一些，老师会出这道题，我认为主要原因在于想让我们对java的类和对象理解更加清楚。

题目集3：7-2（大BOSS）

7-2 日期类设计 (30 分)

参考题目集二中和日期相关的程序，设计一个类DateUtil，该类有三个私有属性year、month、day（均为整型数），其中，year∈[1820,2020] ,month∈[1,12] ,day∈[1,31] , 除了创建该类的构造方法、属性的getter及setter方法外，需要编写如下方法：

public boolean checkInputValidity();//检测输入的年、月、日是否合法
public boolean isLeapYear(int year);//判断year是否为闰年
public DateUtil getNextNDays(int n);//取得year-month-day的下n天日期
public DateUtil getPreviousNDays(int n);//取得year-month-day的前n天日期
public boolean compareDates(DateUtil date);//比较当前日期与date的大小（先后）
public boolean equalTwoDates(DateUtil date);//判断两个日期是否相等
public int getDaysofDates(DateUtil date);//求当前日期与date之间相差的天数
public String showDate();//以“year-month-day”格式返回日期值

应用程序共测试三个功能：

求下n天
求前n天
求两个日期相差的天数

注意：严禁使用Java中提供的任何与日期相关的类与方法，并提交完整源码，包括主类及方法（已提供，不需修改）

程序主方法如下：

略

输入格式:

有三种输入方式（以输入的第一个数字划分[1,3]）：

1 year month day n //测试输入日期的下n天
2 year month day n //测试输入日期的前n天
3 year1 month1 day1 year2 month2 day2 //测试两个日期之间相差的天数

输出格式:

当输入有误时，输出格式如下：
Wrong Format
当第一个数字为1且输入均有效，输出格式如下：
```
year1-month1-day1 next n days is:year2-month2-day2
```
当第一个数字为2且输入均有效，输出格式如下：
```
year1-month1-day1 previous n days is:year2-month2-day2
```

当第一个数字为3且输入均有效，输出格式如下：

The days between year1-month1-day1 and year2-month2-day2 are:值

1.先上类图

2.再上7-2代码

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int year = 0;
        int month = 0;
        int day = 0;

        int choice = input.nextInt();

        if (choice == 1) { // test getNextNDays method
            int m = 0;
            year = Integer.parseInt(input.next());
            month = Integer.parseInt(input.next());
            day = Integer.parseInt(input.next());

            DateUtil date = new DateUtil(year, month, day);

            if (!date.checkInputValidity()) {
                System.out.println("Wrong Format");
                System.exit(0);
            }

            m = input.nextInt();

            if (m < 0) {
                System.out.println("Wrong Format");
                System.exit(0);
            }

            System.out.print(date.getYear() + "-" + date.getMonth() + "-" + date.getDay() + " next " + m + " days is:");
            System.out.println(date.getNextNDays(m).showDate());
        } else if (choice == 2) { // test getPreviousNDays method
            int n = 0;
            year = Integer.parseInt(input.next());
            month = Integer.parseInt(input.next());
            day = Integer.parseInt(input.next());

            DateUtil date = new DateUtil(year, month, day);

            if (!date.checkInputValidity()) {
                System.out.println("Wrong Format");
                System.exit(0);
            }

            n = input.nextInt();

            if (n < 0) {
                System.out.println("Wrong Format");
                System.exit(0);
            }

            System.out.print(
                    date.getYear() + "-" + date.getMonth() + "-" + date.getDay() + " previous " + n + " days is:");
            System.out.println(date.getPreviousNDays(n).showDate());
        } else if (choice == 3) {    //test getDaysofDates method
            year = Integer.parseInt(input.next());
            month = Integer.parseInt(input.next());
            day = Integer.parseInt(input.next());

            int anotherYear = Integer.parseInt(input.next());
            int anotherMonth = Integer.parseInt(input.next());
            int anotherDay = Integer.parseInt(input.next());

            DateUtil fromDate = new DateUtil(year, month, day);
            DateUtil toDate = new DateUtil(anotherYear, anotherMonth, anotherDay);

            if (fromDate.checkInputValidity() && toDate.checkInputValidity()) {
                System.out.println("The days between " + fromDate.showDate() +
                        " and " + toDate.showDate() + " are:"
                        + fromDate.getDaysofDates(toDate));
            } else {
                System.out.println("Wrong Format");
                System.exit(0);
            }
        }
        else{
            System.out.println("Wrong Format");
            System.exit(0);
        }
    }
}
class DateUtil {
    static int[] not_leap = new int[] {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
    static int[] leap = new int[] {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
    private int year;
    private int month;
    private int day;

    public DateUtil(int year,int month,int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }

    public int getYear() {
        return year;
    }

    public int getMonth() {
        return month;
    }

    public int getDay() {
        return day;
    }

    public void setYear(int year) {
        this.year = year;
    }

    public void setMonth(int month) {
        this.month = month;
    }

    public void setDay(int day) {
        this.day = day;
    }

    public boolean checkInputValidity()
    {
        if(year>=1820&&year<=2020&&month>=1&&month<=12&&1<=day&&day<=31)
        {
            if(!((year%4==0&&year%100!=0)||year%400==0)&&month==2&&day>28){
                return false;
            }
            else
                return true;
        }
        else{
            return false;
        }
    }
    public boolean isLeapYear(int year) {
        if((year%4==0&&year%100!=0)||year%400==0)
            return true;
        else
            return false;
    }
    public DateUtil getNextNDays(int n){
        for(;n>=365;) {
            if(isLeapYear(year)) {
                year++;
                n-=366;
            }
            else{
                year++;
                n-=365;
            }
        }
        if(isLeapYear(year)) {
            int xDay=0;
            for(int j=0;j<month-1;j++){
                xDay+=leap[j];
            }
            xDay+=day;
            if(xDay+n>365) {
                year++;
                n=n-367+xDay;
                month=1;
                day=0;
            }
            if(isLeapYear(year))
                for (int i = month; n >=leap[i]; ) {
                    n -=leap[i-1];
                    month++;
                    i++;
                }
            else{
                for (int i = month; n >=not_leap[i]; ) {
                    n -=not_leap[i-1];
                    month++;
                    i++;
                }
            }
        }
        else{
            int xDay=0;
            for(int j=0;j<month-1;j++){
                xDay+=not_leap[j];
            }
            xDay+=day;
            if(xDay+n>365) {
                year++;
                n=n-366+xDay;
            }
            for (int i = month; n >=not_leap[i]; ) {
                n -=not_leap[i];
                month++;
                i++;
            }
        }
        n = -n;
        if(isLeapYear(year)) {
            if (day - n > leap[month - 1]) {
                if (month != 12) {
                    day = day - leap[month - 1] - n;
                    month++;
                    return new DateUtil(year, month, day);
                    //System.out.println(n + " days ago is:" + year + "-" + month + "-" + day);
                } else {
                    day = day - n - leap[0];
                    year++;
                    month = 1;
                    return new DateUtil(year, month, day);
                    //System.out.println(n + " days ago is:" + year + "-" + month + "-" + day);
                }
            } else {
                day = day - n;
                return new DateUtil(year, month, day);
                //System.out.println(n + " days ago is:" + year + "-" + month + "-" + day);
            }
        }
        else{
            if (day - n > not_leap[month - 1]) {
                if (month != 12) {

                    day=day-not_leap[month-1]-n;
                    month++;
                    return new DateUtil(year,month,day);
                    // System.out.println(n + " days ago is:" + year + "-" + month + "-" + day);
                } else {
                    day = day - n - not_leap[0];
                    year++;
                    month = 1;
                    return new DateUtil(year,month,day);
                    //System.out.println(n + " days ago is:" + year + "-" + month + "-" + day);
                }
            } else {
                day = day - n;
                return new DateUtil(year,month,day);
                // System.out.println(n + " days ago is:" + year + "-" + month + "-" + day);
            }
        }

    }
    public boolean compareDates(DateUtil date) {
        if(date.getYear()>year)  return true;
        else if(date.getYear()< year) return false;
        else{
            if(date.getMonth()> month) return true;
            else if(date.getMonth()<month) return false;
            else{
                if(date.getDay()>day) return true;
                else if(date.getDay()<day) return false;
            }
        }
        return true;
    }
    public boolean equalTwoDates(DateUtil date) {
        if(date.getYear()==year&&
                date.getMonth()==month&&
                date.getDay()==day)
            return true;
        else return false;
    }
    public DateUtil getPreviousNDays(int n){
        for(;n>=365;) {
            if(isLeapYear(year)) {
                year--;
                n-=366;
            }
            else{
                year--;
                n-=365;
            }
        }
        if(isLeapYear(year)) {
            int xDay=0;
            for(int j=0;j<month-1;j++){
                xDay+=leap[j];
            }
            xDay+=day;
            if(xDay<n) {
                year--;
                n=n-xDay;
                month=12;
                day=32;
            }
            if(isLeapYear(year))
                for (int i = month; n >=leap[i-1]; ) {
                    n -=leap[i-1];
                    month--;
                    i--;
                }
            else{
                for (int i = month; n >=not_leap[i-1]; ) {
                    n -=not_leap[i-1];
                    month--;
                    i-- ;
                }
            }
        }
        else{
            int xDay=0;
            for(int j=0;j<month-1;j++)
                xDay+=not_leap[j];
            xDay+=day;
            if(xDay<n) {
                year--;
                n=n-xDay;
                month=12;
                day=30;
            }
            if(isLeapYear(year))
                for (int i = month; n >=leap[i-1]; ) {
                    n -=leap[i-1];
                    month--;
                    i--;
                }
            else{
                for (int i = month; n >=not_leap[i-1]; ) {
                    n -= not_leap[i - 1];
                    month--;
                    i--;
                }
            }
        }
        if (isLeapYear(year)){
            if (day - n < 1) {
                if (month != 1) {
                    day = leap[month-2]-(n-day);
                    month--;
                    return new DateUtil(year,month,day);
                } else {
                    day = day + leap[11] - n;
                    year--;
                    month = 12;
                    return new DateUtil(year,month,day);
                }
            }
            else {
                day = day - n;
                return new DateUtil(year,month,day);
            }
        }
        else{
            if (day - n < 1) {
                if (month != 1) {
                    day = not_leap[month-2]-(n-day);
                    month--;
                    return new DateUtil(year,month,day);
                } else {
                    day = day + not_leap[11] - n;
                    year--;
                    month = 12;
                    return new DateUtil(year,month,day);
                }
            } else {
                day = day - n;
                return new DateUtil(year,month,day);
            }
        }
    }
    public String showDate() {
        String s=String.format("%d-%d-%d",year,month,day);
        return s;
    }
    public int getDaysofDates(DateUtil date) {
        int x,y=0,z=1,x1,y1=0,z1=0;
        for(x=1;x<year;x++) {
            if(isLeapYear(x))
                y+=366;
            else
                y+=365;
        }
        if(isLeapYear(year)){
            for(z=0;z<(month-1);z++){
                y+=leap[z];
            }
            y+=day;

        }
        else{
            for(z=0;z<(month-1);z++)
                y+=not_leap[z];
            y+=day;
        }
        for(x1=1;x1<date.getYear();x1++){
            if(isLeapYear(x1)){
                y1+=366;
            }
            else y1+=365;
        }
        if(isLeapYear(date.getYear())){
            for(z1=0;z1<(date.getMonth()-1);z1++){
                y1+=leap[z1];
            }
            y1+=date.getDay();
        }
        else{
            for(z1=0;z1<(date.getMonth()-1);z1++)
                y1+=not_leap[z1];
            y1+=date.getDay();
        }
        return Math.abs(y-y1);
    }
}

3.我的心得：这道题目难度瞬间提升了一个档次，需要考虑到的情况是非常多的，我认为这里更多考察了大家对原来编程基础运用，还有就是对一个简单的类似于系统型的编程，非常考察大家的能力，这里我给的难度是Hard(♥)。面对这种题目，首先是一定要稳住心态，保证自己头脑的清楚，否则非常容易漏情况，导致后续进行再次修改造成极其大的困扰。

题目集3：7-3（究极大BOSS）

参考题目7-2的要求，设计如下几个类：DateUtil、Year、Month、Day，其中年、月、日的取值范围依然为：year∈[1900,2050] ,month∈[1,12] ,day∈[1,31] , 设计类图如下：

应用程序共测试三个功能：

求下n天
求前n天
求两个日期相差的天数

注意：严禁使用Java中提供的任何与日期相关的类与方法，并提交完整源码，包括主类及方法（已提供，不需修改）

输入格式:

有三种输入方式（以输入的第一个数字划分[1,3]）：

1 year month day n //测试输入日期的下n天
2 year month day n //测试输入日期的前n天
3 year1 month1 day1 year2 month2 day2 //测试两个日期之间相差的天数

输出格式:

当输入有误时，输出格式如下：
Wrong Format
当第一个数字为1且输入均有效，输出格式如下：
```
year-month-day
```
当第一个数字为2且输入均有效，输出格式如下：
```
year-month-day
```
当第一个数字为3且输入均有效，输出格式如下：
```
天数值
```

1.老规矩，先上类图：

2.再上代码：

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int year = 0;
        int month = 0;
        int day = 0;

        int choice = input.nextInt();

        if (choice == 1) { // test getNextNDays method
            int m = 0;
            year = Integer.parseInt(input.next());
            month = Integer.parseInt(input.next());
            day = Integer.parseInt(input.next());

            DateUtil date = new DateUtil(year, month, day);

            if (!date.checkInputValidity()) {
                System.out.println("Wrong Format");
                System.exit(0);
            }

            m = input.nextInt();

            if (m < 0) {
                System.out.println("Wrong Format");
                System.exit(0);
            }

            System.out.println(date.getNextNDays(m).showDate());
        } else if (choice == 2) { // test getPreviousNDays method
            int n = 0;
            year = Integer.parseInt(input.next());
            month = Integer.parseInt(input.next());
            day = Integer.parseInt(input.next());

            DateUtil date = new DateUtil(year, month, day);

            if (!date.checkInputValidity()) {
                System.out.println("Wrong Format");
                System.exit(0);
            }

            n = input.nextInt();

            if (n < 0) {
                System.out.println("Wrong Format");
                System.exit(0);
            }

            System.out.println(date.getPreviousNDays(n).showDate());
        } else if (choice == 3) {    //test getDaysofDates method
            year = Integer.parseInt(input.next());
            month = Integer.parseInt(input.next());
            day = Integer.parseInt(input.next());

            int anotherYear = Integer.parseInt(input.next());
            int anotherMonth = Integer.parseInt(input.next());
            int anotherDay = Integer.parseInt(input.next());

            DateUtil fromDate = new DateUtil(year, month, day);
            DateUtil toDate = new DateUtil(anotherYear, anotherMonth, anotherDay);

            if (fromDate.checkInputValidity() && toDate.checkInputValidity()) {
                System.out.println(fromDate.getDaysofDates(toDate));
            } else {
                System.out.println("Wrong Format");
                System.exit(0);
            }
        }
        else{
            System.out.println("Wrong Format");
            System.exit(0);
        }
    }
}

class DateUtil {

    private Day day;

    public DateUtil() {
    }

    public DateUtil(int d, int m, int y) {
        day = new Day(d, m, y);
    }

    public Day getDay() {
        return day;
    }

    public void setDay(Day d) {
        this.day = d;
    }
    public boolean checkInputValidity() {
        boolean flag = day.getMonth().validate()&& day.getMonth().getYear().validate()&&day.validate();
        return flag;
    }

    public boolean compareDates(DateUtil date) {
        if(date.getDay().getMonth().getYear().getValue()>day.getMonth().getYear().getValue())  return true;
        else if(date.getDay().getMonth().getYear().getValue()<day.getMonth().getYear().getValue()) return false;
        else{
            if(date.getDay().getMonth().getValue()>day.getMonth().getValue()) return true;
            else if(date.getDay().getMonth().getValue()<day.getMonth().getValue()) return false;
            else{
                if(date.getDay().getValue()>day.getValue()) return true;
                else if(date.getDay().getValue()<day.getValue()) return false;
            }
        }
 return true;
    }
    public boolean equalTwoDates(DateUtil date) {
        if(date.getDay().getMonth().getYear().getValue()==day.getMonth().getYear().getValue()&&
                date.getDay().getMonth().getValue()==day.getMonth().getValue()&&
                date.getDay().getValue()==day.getValue())
            return true;
        else return false;
    }

    public String showDate() {
        String s=String.format("%d-%d-%d",day.getMonth().getYear().getValue(),day.getMonth().getValue(),day.getValue());
        return s;
    }

    public DateUtil getNextNDays(int n) {
        for(int i=0;i<n;i++){
            day.dayIncrement();
            if(!day.validate()){
                day.getMonth().monthIncrement();
                day.resetMin();
                if(!day.getMonth().validate()){
                    day.getMonth().getYear().yearIncrement();
                    day.getMonth().resetMin();
                }
            }
        }
        return new DateUtil(day.getMonth().getYear().getValue(),day.getMonth().getValue(),day.getValue());
    }

    public DateUtil getPreviousNDays(int n) {
        for (int i = 0; i < n; i ++) {
            day.dayReduction();
            if (!day.validate()) {
                day.getMonth().monthReduction();
                
                if (!day.getMonth().validate()) {
                    day.getMonth().getYear().yearReduction();
                    day.getMonth().resetMax();
                }
                day.resetMax();
            }
        }
        return new DateUtil(day.getMonth().getYear().getValue(),day.getMonth().getValue(),day.getValue());
    }
    public boolean isLeapYear(int year) {
        if((year%4==0&&year%100!=0)||year%400==0)
            return true;
        else
            return false;
    }
    public int getDaysofDates(DateUtil date) {
        int x,y=0,z=1,x1,y1=0,z1=0;
        int[] not_leap = new int[] {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
        int[] leap = new int[] {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
        for(x=1;x<day.getMonth().getYear().getValue();x++)
        {
            if(isLeapYear(x)){
                y+=366;
            }
            else
                y+=365;
        }
        if(isLeapYear(day.getMonth().getYear().getValue())){
            for(z=0;z<(day.getMonth().getValue()-1);z++){
                y+=leap[z];
            }
            y+=day.getValue();

        }
        else{
            for(z=0;z<(day.getMonth().getValue()-1);z++)
            {
                y+=not_leap[z];
            }
            y+=day.getValue();

        }
        for(x1=1;x1<date.getDay().getMonth().getYear().getValue();x1++){
            if(isLeapYear(x1)){
                y1+=366;
            }
            else y1+=365;
        }
        if(isLeapYear(date.getDay().getMonth().getYear().getValue())){
            for(z1=0;z1<(date.getDay().getMonth().getValue()-1);z1++){
                y1+=leap[z1];
            }
            y1+=date.getDay().getValue();

        }
        else{
            for(z1=0;z1<(date.getDay().getMonth().getValue()-1);z1++)
            {
                y1+=not_leap[z1];
            }
            y1+=date.getDay().getValue();

        }
        return Math.abs(y-y1);
    }
    }



class Day {

    private int value;
    private Month month;
    private int[] mon_maxnum = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};

    public Day() {
    }

    public Day(int yearValue, int monthValue, int dayValue) {
        value = dayValue;
        month = new Month(yearValue, monthValue);
    }

    public int getValue() {
        return value;
    }

    public void setValue(int value) {
        this.value = value;
    }

    public Month getMonth() {
        return month;
    }

    public void setMonth(Month value) {
        month = value;
    }

    public void resetMin() {
        value = 1;
    }

    public void resetMax(){
        if(month.getYear().isLeapYear()&&month.getValue()==2)
        value = mon_maxnum[month.getValue()-1]+1;
        else
            value=mon_maxnum[month.getValue()-1];
    }

    public boolean validate() {
        if(month.getYear().isLeapYear()&&month.getValue()==2){
            if(value>=1&&value<=mon_maxnum[month.getValue()-1]+1) return true;
            else return false;
        }
        else{
            if(value>=1&&value<=mon_maxnum[month.getValue()-1]) return true;
            else return false;
        }
    }

    public void dayIncrement() {
        value += 1;
    }

    public void dayReduction() {
        value -= 1;
    }

}

class Month {

    private int value;
    private Year year;

    public Month() {
        super();
    }

    public Month(int yearValue, int monthValue) {
        value = monthValue;
        year = new Year(yearValue);
    }

    public int getValue() {
        return value;
    }

    public void setValue(int value) {
        this.value = value;
    }

    public Year getYear() {
        return year;
    }

    public void setYear(Year year) {
        this.year = year;
    }

    public void resetMin() {
        value = 1;
    }

    public void resetMax() {
        value = 12;
    }
    public boolean validate() {
        if(value>=1&&value<=12) return true;
        else return false;
    }

    public void monthIncrement() {
        value += 1;
    }

    public void monthReduction() {
        value -= 1;
    }
}

class Year {

    private int value;

    public Year() {
    }

    public Year(int value) {
        this.value = value;
    }

    public int getValue() {
        return value;
    }

    public void setValue(int value) {
        this.value = value;
    }

    public boolean isLeapYear() {
        if((value % 4 == 0 && value % 100 != 0) || value % 400 == 0){
            return true;
        } else{
            return false;
        }
    }
    public boolean validate() {
        if (value < 1900 || value > 2050) {
            return false;
        } else {
            return true;
        }
    }
    public void yearIncrement() {
        value += 1;
    }

    public void yearReduction() {
        value -= 1;
    }

}

3.我的心得：来，我们来看到这道题，我敢保证所有刚学java的同学99%会被吓到，确实，这道题是有一定难度的。首先，它的复杂程度不亚于7-2。其次，就是它真正把java中我们需要基本掌握的基础知识（不同于C语言）对象和类是发挥到极致了。所以这道题我给出了Hard（♥♥）的难度系数，堪称恐怖。那么我们应该怎么去做呢？首先，跟上一题一样，稳住心态，压下浮躁和抱怨，静下心好好看看题目，这道题目其实和7-2的思路是一样的，（只要7-2不是借鉴的（手动狗头）），还是可以接受的，依照7-2进行java类的分析，依次将各自功能分析清楚，一个个进行匹配，开始写代码的时候是有一点的困难，但是在逐渐进入状态还是比较清晰的，还有一个问题就是测试方面，这个也是把人要磨死，要学会从出题人的角度考虑问题，去测一些边界值，例如这道题的二月份最后一天，十二月份最后一天等等会产生连锁反应的地方都需要反复推敲。

################################################################################################################################################################

（3）踩坑心得

ps:这一块要是展开说估计真的得说好久（本人较菜，踩了超级多坑），所以我会简单说一些同学们会非常容易踩的巨坑。

##①##题目集2 7-2

1.奇偶校验位采用奇校验，这里的校验是存在比较多的测试点的，想要把测试点全都一次性过，还是有点难度的。

两组数据结束符和奇偶校验均不合格

注意要判断结束符和奇偶校验要同时进行，否则容易输出了别的结果：parity check error

三组数据，含结束符错误数据、奇偶校验错误数据和正常值

注意要控制所有字符串的合理读入，并且保证所有正常情况皆为正常

## ②##题目集3 7-1

1.判断方程是否属于二元一次方程，若不是，则输出错误输入

注意在a=0时，方程属于一元一次方程，不属于二元一次方程，需要排除该情况

##③##题目集3 7-2

1.二月份的边界值测算需要考虑到是否为闰年

注意在闰年时二月29天，而平年二月28天，判断之前的天数和之后的天数，都需要将年数一个个判断

##④##题目集3 7-3

1.判断日期是否错误

注意在闰年才有2月29天，在最开始就需要进行判读该测试点正误

（4）改进建议

##①##题目集2 7-2

1.更多去习惯使用java中的方法而不是还是停留在c语言层面写程序

public boolean checkInputValidity();//检测输入的年、月、日是否合法
public boolean isLeapYear(int year);//判断year是否为闰年
public DateUtil getNextNDays(int n);//取得year-month-day的下n天日期
public DateUtil getPreviousNDays(int n);//取得year-month-day的前n天日期
public boolean compareDates(DateUtil date);//比较当前日期与date的大小（先后）
public boolean equalTwoDates(DateUtil date);//判断两个日期是否相等
public int getDaysofDates(DateUtil date);//求当前日期与date之间相差的天数
public String showDate();//以“year-month-day”格式返回日期值

类似这种java方法类的使用

##②##题目集3 7-1

1.学会把求discriminant的所谓的函数利用方法进行修饰，并且尽量简化代码的复杂程度

##③##题目集3 7-2

1.将求两天之间所含有的天数方法进行改进，原方法太过于long

public int getDaysofDates(DateUtil date) {
        int i = 0;
        while (!equalTwoDates(date)) {
            if (compareDates(date)) {
                day.dayIncrement();
                if (!day.validate()) {
                    day.resetMin();
                    day.getMonth().monthIncrement();
                    if (!day.getMonth().validate()) {
                        day.getMonth().resetMin();
                        day.getMonth().getYear().yearIncrement();
                    }
                }
            } else {
                day.dayReduction();
                if (!day.validate()) {
                    day.getMonth().monthReduction();
                    if (!day.getMonth().validate()) {
                        day.getMonth().getYear().yearReduction();
                        day.getMonth().resetMax();
                    }
                    day.resetMax();
                }
            }
            i += 1;
        }
        return i;
    }

##③##题目集3 7-3

1.在该题中getDaysofDates可以进行优化

 public int getDaysofDates(DateUtil date) {
        int i = 0;
        while (!equalTwoDates(date)) {
            if (compareDates(date)) {
                day.dayIncrement();
                if (!day.validate()) {
                    day.resetMin();
                    day.getMonth().monthIncrement();
                    if (!day.getMonth().validate()) {
                        day.getMonth().resetMin();
                        day.getMonth().getYear().yearIncrement();
                    }
                }
            } else {
                day.dayReduction();
                if (!day.validate()) {
                    day.getMonth().monthReduction();
                    if (!day.getMonth().validate()) {
                        day.getMonth().getYear().yearReduction();
                        day.getMonth().resetMax();
                    }
                    day.resetMax();
                }
            }
            i += 1;
        }
        return i;

################################################################################################################################################################

（5）总结

收获
- 对java的类和对象了解更加深刻，并且已经开始学着去使用它。
- 编码的优化程度大大提高，程序的可读性更好了。
不足

一.对java的熟练程度有待提高，还是过于依赖之前C语言的固有思维。

二.对题目的细节考虑不清，非常容易犯一些细节错误，造成测试点的错误。

通过本阶段三次题目集的训练对教师、课程、作业、实验、课上及课下组织方式等方面提出的改进建议及意见

老师的教学速度是可以接受的，但是试题难度跳跃性过大，学生需要花费非常多时间去学习掌握。
希望老师可以对pta的题目进行分析和讲解。

------------恢复内容结束------------

标签：DateUtil,总结性,题目,int,month,Blog,public,year,day
来源： https://www.cnblogs.com/linyangyu/p/16124342.html

题目集1~3的总结性Blog

（1）前言

知识点

4 难度分析

（2）设计与分析

题目集2：7-2

输入格式:

输出格式:

题目集3：7-1

输入格式:

输出格式:

1.类图

题目集3：7-2（大BOSS）

输入格式:

输出格式:

题目集3：7-3（究极大BOSS）

输入格式:

输出格式:

（3）踩坑心得

ps:这一块要是展开说估计真的得说好久（本人较菜，踩了超级多坑），所以我会简单说一些同学们会非常容易踩的巨坑。

##①##题目集2 7-2

1.判断方程是否属于二元一次方程，若不是，则输出错误输入

（4）改进建议

##①##题目集2 7-2

##②##题目集3 7-1

##③##题目集3 7-2

##③##题目集3 7-3

################################################################################################################################################################

（5）总结

收获

不足

通过本阶段三次题目集的训练对教师、课程、作业、实验、课上及课下组织方式等方面提出的改进建议及意见