首页 > 其他分享> 文章详细

题目集1~3的总结性Blog

2022-04-10 00:02:01 阅读：164 来源： 互联网

标签：DateUtil 总结性题目 int month Blog public year day

（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. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9

题目集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）总结

收获

不足

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