JAVA阶段性作业总结二

一、前言

　　本篇博客主要是对Java第二阶段作业进行总结。相较于第一阶段作业，第二阶段作业更多是关于Java的三大特性：封装、继承与多态。第四次作业有三道题，包括7-1 水文数据校验处理、7-2日期问题面对对象设计（聚合一）、7-3 图形继承，涉及的知识点有正则表达式、 StringBuilder用法、类的聚合、类的继承、子类重写父类方法等等，题量虽不多但难度较 大。第五次作业有四道题，包括7-5 日期问题面向对象设计（聚合二）、7-4 统计Java程序中关键词的出现次数等，涉及的知识点有类的聚合、Java关键字、正则表达式、Map集合、插入排序、选择排序及冒泡排序三种算法等，题量适中难度适中。第六次作业有六道题，包括7-5 图形继承与多态、7-6 实现图形接口及多态性等，题量虽多但难度不大。通过这几次作业，我进一步的学习了解了Java的三大特性，对Java语法也有进一步的了解。

二、设计与分析

7-2 日期问题面向对象设计（聚合一） (35 分)

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

 

 

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

1. 求下n天
2. 求前n天
3. 求两个日期相差的天数

注意：严禁使用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且输入均有效，输出格式如下：

  天数值

我的代码：

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int n = input.nextInt();
        int year = input.nextInt();
        int month = input.nextInt();
        int day = input.nextInt();
        DateUtil q = new DateUtil(year, month, day);
        switch (n){
            case 1:
                int num = input.nextInt();
                if (num < 0 || !q.checkInputvalidity()) {
                    System.out.print("Wrong Format");
                } else {
                    System.out.print(q.getNextNdays(num).showDate());
                }
                break;
            case 2:
                int num1 = input.nextInt();
                if (num1 < 0 || !q.checkInputvalidity()) {
                    System.out.print("Wrong Format");
                } else {
                    System.out.print(q.getPreviousNDays(num1).showDate());
                }
                break;
            case 3:
                int y = input.nextInt();
                int m = input.nextInt();
                int d = input.nextInt();
                DateUtil p = new DateUtil(y,m,d);
                if (!q.checkInputvalidity() || !p.checkInputvalidity()) {
                    System.out.print("Wrong Format");
                } else {
                    System.out.print(q.getDaysofDates(p));
                }
                break;
            default:System.out.print("Wrong Format");break;
        }
    }

}

class Year{
    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 true;
        }else {
            return false;
        }
    }
    public void yearIncrement(){
        value = value + 1;
    }
    public void yaerReduction(){
        value = value - 1;
    }
}
class Month{
    int value;
    Year year;
    public Month(){
    }
    public Month(int yearValue,int monthValue){
        this.year = new Year(yearValue);
        this.value = monthValue;
    }

    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 = value + 1;
    }
    public void monthReduction(){
        value = value - 1;
    }
}
class Day{
    int value;
    Month month;
    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){
        this.month = new Month(yearValue,monthValue);
        this.value = dayValue;
    }

    public int getValue() {
        return value;
    }
    public void setValue(int value){
        this.value = value;
    }
    public Month getMonth(){
        return month;
    }
    public void setMonth(Month value){
        this.month = value;
    }
    public void resetMin(){
        value = 1;
    }
    public void resetMax(){
        value = mon_maxnum[month.getValue()-1];
    }
    public boolean validate(){
        if (this.getMonth().getYear().isLeapYear()){
            mon_maxnum[1] = 29;
        }
        if (month.getValue() > 12 || month.getValue() < 1){
            return false;
        }
        if (value < 1 || value > mon_maxnum[month.getValue()-1]){
            return false;
        }else {
            return true;
        }
    }
    public void dayIncrement(){
        value = value + 1;
    }
    public void dayReduction(){
        value = value - 1;
    }
}
class DateUtil{
    Day day;
    public DateUtil(){
    }
    public DateUtil(int d,int m,int y){
        this.day = new Day(d,m,y);
    }
    public Day getDay(){
        return day;
    }
    public void setDay(Day d){
        this.day = d;
    }
    public boolean checkInputvalidity(){
        if (day.validate() && day.getMonth().validate() && day.getMonth().getYear().validate()){
            return true;
        }else{
            return false;
        }
    }
    public boolean compareDates(DateUtil date) {
        if (date.getDay().getMonth().getYear().getValue() < this.getDay().getMonth().getYear().getValue()) {
            return false;
        } else if (date.getDay().getMonth().getYear().getValue() == this.getDay().getMonth().getYear().getValue() && date.getDay().getMonth().getValue() < this.getDay().getMonth().getValue()) {
            return false;
        } else if (date.getDay().getMonth().getYear().getValue() == this.getDay().getMonth().getYear().getValue() && date.getDay().getMonth().getValue() == this.getDay().getMonth().getValue() && date.getDay().getValue() < this.getDay().getValue()) {
            return false;
        } else {
            return true;
        }
    }
    public boolean equalTwoDates(DateUtil date) {
        if (date.getDay().getMonth().getYear().getValue() == this.getDay().getMonth().getYear().getValue() && date.getDay().getMonth().getValue() == this.getDay().getMonth().getValue() && date.getDay().getValue() == this.getDay().getValue()) {
            return true;
        }else {
            return false;
        }
    }

    public String showDate(){
        return day.getMonth().getYear().getValue()+"-"+day.getMonth().getValue()+"-"+day.getValue();
    }
    public int syts(DateUtil d){
        int num = 0;
        int a[] = {31,28,31,30,31,30,31,31,30,31,30,31};
        int i = 12;
        while (i > d.getDay().getMonth().getValue()){
            num = num + a[i-1];
            i--;
        }
        num = num + a[d.getDay().getMonth().getValue()-1]-d.getDay().getValue();
        if (d.getDay().getMonth().getYear().isLeapYear() && d.getDay().getMonth().getValue() <= 2){
            num =num + 1;
        }
        return num;
    }
    //求下n天
    public DateUtil getNextNdays(int n){
        int a[] = {0,31,28,31,30,31,30,31,31,30,31,30,31};
        int y = this.getDay().getMonth().getYear().getValue();
        int m = this.getDay().getMonth().getValue();
        int d = this.getDay().getValue();
        int sum = 0;
        int num = syts(this);
        int ynum = 0;
        int mnum = 0;
        if (this.getDay().getMonth().getYear().isLeapYear()){
            a[2] = 29;
        }else {
            a[2]= 28;
        }
        if (n > num){//n大于本年剩余天数
            n = n - num;
            y ++;
            if (new Year(y).isLeapYear()){
                ynum = 366;
            }else {
                ynum = 365;
            }
            //大于本年剩余天数但小于下一年天数
            if(n < ynum){
                int i = 0;
                for (i = 0 ;i < 12 && sum < n; i++){
                    sum = sum + a[i];
                }
                m = i-1;
                d = n - sum + a[i-1] ;
            }else if (n > ynum){//大于本年剩余天数且大于下一年天数
                int j = 0;
                while (n-ynum > 0){
                    if (new Year(y).isLeapYear()){
                        ynum = 366;
                    }else {
                        ynum = 365;
                    }
                    n=n-ynum;
                    y ++;
                }
                for (j = 0; j < 12 && sum < n ; j ++){
                    sum = sum + a[j];
                }
                m = j-1;
                d = n - sum + a[j-1] ;
            }

        }else { //小于本年剩余天数
            int k = 0;
            mnum = a[m]-d;
            if (n <= mnum){  //小于本月剩余天数
                d = d + n;
            }else {
                n = n - mnum;
                for (k = m+1;k <= 12 && sum < n ; k ++){
                    sum = sum + a[k];
                }
                m = k-1;
                d = n - sum + a[k-1] ;
            }
        }
        return new DateUtil(y,m,d);
    }
    // 求n天前
    public DateUtil getPreviousNDays(int n){
        int a[] = {0,31,28,31,30,31,30,31,31,30,31,30,31};
        int y = this.getDay().getMonth().getYear().getValue();
        int m = this.getDay().getMonth().getValue();
        int d = this.getDay().getValue();
        int sum = 0;
        int ynum = 0;
        int mnum = 0;
        if (this.getDay().getMonth().getYear().isLeapYear()){
            a[2] = 29;
        }else {
            a[2]= 28;
        }
        if (new Year(y).isLeapYear()){
            ynum = 366;
        }else {
            ynum = 365;
        }
        int num = ynum - syts(this);//今年已有多少天
        //n天前不是本年
        if (n > num){
            n = n - num;
            y --;
            if (new Year(y).isLeapYear()){
                ynum = 366;
            }else {
                ynum = 365;
            }
            if (n > ynum){ //上某一年
                while (n-ynum >0){
                    if (new Year(y).isLeapYear()){
                        ynum = 366;
                    }else {
                        ynum = 365;
                    }
                    n=n-ynum;
                    y --;
                }
                int j = 0;
                if (new Year(y).isLeapYear()){
                    a[2] = 29;
                }else {
                    a[2] = 28;
                }
                for (j = 12; j > 0 && sum < n ; j --){
                    sum = sum + a[j];
                }
                m = j+1;
                d = sum - n ;

            }else {
                int j = 0;
                for (j = 12; j > 0 && sum < n ; j --){
                    sum = sum + a[j];
                }
                m = j+1;
                d = sum - n;
            }
        }else {     //n天前是本年
            if (n > d){ //不是本月
                n = n-d;
                int k = 0;
                for (k = m-1; k > 0 && sum < n ; k --){
                    sum = sum + a[k];
                }
                m = k + 1;
                d = sum - n;
            }else {
                d = d - n;
            }

        }
        return new DateUtil(y,m,d);
    }
    public int getDaysofDates(DateUtil date){
        DateUtil d1 = this;
        DateUtil d2 = date;
        int y1 = d1.getDay().getMonth().getYear().getValue();
        int y2 = d2.getDay().getMonth().getYear().getValue();
        int anum = 0;
        int bnum = 0;
        int ynum = 0;
        int sum = 0;
        anum = syts(d1);
        bnum = syts(d2);

        if (y1 > y2){
            if (new Year(y1).isLeapYear()){
                ynum = 366;
            }else {
                ynum = 365;
            }
            sum = sum + bnum + ynum -anum;
            y2++;
            while (y2 <= y1-1){
                if (new Year(y2).isLeapYear()){
                    ynum = 366;
                }else {
                    ynum = 365;
                }
                sum = sum + ynum;
                y2++;
            }
        }else if (y1 < y2) {
            if (new Year(y2).isLeapYear()){
                ynum = 366;
            }else {
                ynum = 365;
            }
            sum = sum + anum + ynum -bnum;
            y1++;
            while (y1 <= y2-1){
                if (new Year(y1).isLeapYear()){
                    ynum = 366;
                }else {
                    ynum = 365;
                }
                sum = sum + ynum;
                y1++;
            }
        }else {
            int m1 = d1.getDay().getMonth().getValue();
            int m2 = d2.getDay().getMonth().getValue();

            if (d1.getDay().getMonth().getValue() < d2.getDay().getMonth().getValue()){
                sum = d2.getDay().getValue() + d1.getDay().mon_maxnum[d1.getDay().getMonth().getValue()-1] - d1.getDay().getValue();
                m1++;
                while(m1 <= m2-1){
                    if (new Year(y1).isLeapYear()){
                        d1.getDay().mon_maxnum[1] = 29;
                    }else {
                        d1.getDay().mon_maxnum[1] = 28;
                    }
                    sum = sum + d1.getDay().mon_maxnum[m1-1];
                    m1++;
                }
            }else if (d1.getDay().getMonth().getValue() >d2.getDay().getMonth().getValue()){
                sum = d1.getDay().getValue() + d2.getDay().mon_maxnum[d2.getDay().getMonth().getValue()-1] - d2.getDay().getValue();
                m2++;
                while(m2 <= m1-1){
                    if (new Year(y1).isLeapYear()){
                        d1.getDay().mon_maxnum[1] = 29;
                    }else {
                        d1.getDay().mon_maxnum[1] = 28;
                    }
                    sum = sum + d2.getDay().mon_maxnum[m2-1];
                    m2++;
                }
            }else {
                if (d1.getDay().getValue() > d2.getDay().getValue()){
                    sum = d1.getDay().getValue() - d2.getDay().getValue();
                }else if (d1.getDay().getValue() < d2.getDay().getValue()){
                    sum = d2.getDay().getValue() - d1.getDay().getValue();
                }else {
                    sum = 0;
                }
            }
        }
        return sum;
    }
}

 

7-5 日期问题面向对象设计（聚合二） (40 分)

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

 

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

1. 求下n天
2. 求前n天
3. 求两个日期相差的天数

注意：严禁使用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:值

我的代码：

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int n = input.nextInt();
        int year = input.nextInt();
        int month = input.nextInt();
        int day = input.nextInt();
        DateUtil q = new DateUtil(year, month, day);
        switch (n){
            case 1:
                int num = input.nextInt();
                if (num < 0 || !q.checkInputvalidity()) {
                    System.out.print("Wrong Format");
                } else {
                    System.out.print(q.showDate()+" next "+num+" days is:"+ q.getNextNdays(num).showDate());
                }
                break;
            case 2:
                int num1 = input.nextInt();
                if (num1 < 0 || !q.checkInputvalidity()) {
                    System.out.print("Wrong Format");
                } else {
                    System.out.print(q.showDate()+" previous "+num1+" days is:"+ q.getPreviousNDays(num1).showDate());
                }
                break;
            case 3:
                int y = input.nextInt();
                int m = input.nextInt();
                int d = input.nextInt();
                DateUtil p = new DateUtil(y,m,d);
                if (!q.checkInputvalidity() || !p.checkInputvalidity()) {
                    System.out.print("Wrong Format");
                } else {
                    System.out.print("The days between "+q.showDate()+" and "+p.showDate()+" are:"+q.getDaysofDates(p));
                }
                break;
            default:System.out.print("Wrong Format");break;
        }
    }

}

class Year{
    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 >= 1820 && value <= 2020){
            return true;
        }else {
            return false;
        }
    }
    public void yearIncrement(){
        value = value + 1;
    }
    public void yaerReduction(){
        value = value - 1;
    }
}
class Month{
    int value;
    public Month(){
    }
    public Month(int Value){
        this.value = Value;
    }

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

    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 = value + 1;
    }
    public void monthReduction(){
        value = value - 1;
    }
}
class Day{
    int value;
    public Day(){
    }
    public Day(int Value){
        this.value = Value;
    }
    public int getValue() {
        return value;
    }
    public void setValue(int value){
        this.value = value;
    }
    public void dayIncrement(){
        value = value + 1;
    }
    public void dayReduction(){
        value = value - 1;
    }
}
class DateUtil{
    Year year;
    Month month;
    Day day;
    int mon_maxnum[] = {31,28,31,30,31,30,31,31,30,31,30,31};
    public DateUtil(){
    }
    public DateUtil(int y,int m,int d){
        this.year = new Year(y);
        this.month = new Month(m);
        this.day = new Day(d);
    }

    public Year getYear() {
        return year;
    }
    public void setYear(Year year) {
        this.year = year;
    }
    public Month getMonth() {
        return month;
    }
    public void setMonth(Month month) {
        this.month = month;
    }
    public Day getDay(){
        return day;
    }
    public void setDay(Day day){
        this.day = day;
    }
    public void setDayMin(){
        day.setValue(1);
    }
    public void setDayMax(){
        day.setValue(mon_maxnum[this.month.getValue()]);
    }
    public boolean checkInputvalidity(){
        if (this.getYear().isLeapYear()){
            mon_maxnum[1] = 29;
        }
        if (month.getValue() > 12 || month.getValue() < 1){
            return false;
        }
        if (this.getDay().getValue() > 0 && this.getDay().getValue() <= this.mon_maxnum[this.getMonth().getValue()-1] && this.getMonth().validate() && this.getYear().validate()){
            return true;
        }else{
            return false;
        }
    }
    public boolean compareDates(DateUtil date) {
        if (date.getYear().getValue() < this.getYear().getValue()) {
            return false;
        } else if (date.getYear().getValue() == this.getYear().getValue() && date.getMonth().getValue() < this.getMonth().getValue()) {
            return false;
        } else if (date.getYear().getValue() == this.getYear().getValue() && date.getMonth().getValue() == this.getMonth().getValue() && date.getDay().getValue() < this.getDay().getValue()) {
            return false;
        } else {
            return true;
        }
    }
    public boolean equalTwoDates(DateUtil date) {
        if (date.getYear().getValue() == this.getYear().getValue() && date.getMonth().getValue() == this.getMonth().getValue() && date.getDay().getValue() == this.getDay().getValue()) {
            return true;
        }else {
            return false;
        }
    }

    public String showDate(){
        return this.getYear().getValue()+"-"+this.getMonth().getValue()+"-"+day.getValue();
    }
    public int syts(DateUtil d){
        int num = 0;
        int a[] = {31,28,31,30,31,30,31,31,30,31,30,31};
        int i = 12;
        while (i > d.getMonth().getValue()){
            num = num + a[i-1];
            i--;
        }
        num = num + a[d.getMonth().getValue()-1]-d.getDay().getValue();
        if (d.getYear().isLeapYear() && d.getMonth().getValue() <= 2){
            num =num + 1;
        }
        return num;
    }
    //求下n天
    public DateUtil getNextNdays(int n){
        int a[] = {0,31,28,31,30,31,30,31,31,30,31,30,31};
        int y = this.getYear().getValue();
        int m = this.getMonth().getValue();
        int d = this.getDay().getValue();
        int sum = 0;
        int num = syts(this);
        int ynum = 0;
        int mnum = 0;
        if (this.getYear().isLeapYear()){
            a[2] = 29;
        }else {
            a[2]= 28;
        }
        if (n > num){//n大于本年剩余天数
            n = n - num;
            y ++;
            if (new Year(y).isLeapYear()){
                ynum = 366;
            }else {
                ynum = 365;
            }
            //大于本年剩余天数但小于下一年天数
            if(n < ynum){
                int i = 0;
                for (i = 0 ;i <= 12 && sum < n; i++){
                    sum = sum + a[i];
                }
                m = i-1;
                d = n - sum + a[i-1] ;
            }else {
                int j = 0;
                while (n-ynum > 0){
                    if (new Year(y).isLeapYear()){
                        ynum = 366;
                    }else {
                        ynum = 365;
                    }
                    n=n-ynum;
                    y ++;
                }
                if (new Year(y).isLeapYear()){
                    a[2] = 29;
                }else {
                    a[2] = 28;
                }
                for (j = 0; j <= 12 && sum < n ; j ++){
                    sum = sum + a[j];
                }
                m = j - 1;
                d = n - sum + a[j-1] ;
            }

        }else { //小于本年剩余天数
            int k = 0;
            mnum = a[m]-d;
            if (n <= mnum){  //小于本月剩余天数
                d = d + n;
            }else {
                n = n - mnum;
                if (new Year(y).isLeapYear()){
                    a[2] = 29;
                }else {
                    a[2] = 28;
                }
                for (k = m+1;k <= 12 && sum < n ; k ++){
                    sum = sum + a[k];
                }
                m = k-1;
                d = n - sum + a[k-1] ;
            }
        }
        return new DateUtil(y,m,d);
    }
    // 求n天前
    public DateUtil getPreviousNDays(int n){
        int a[] = {0,31,28,31,30,31,30,31,31,30,31,30,31};
        int y = this.getYear().getValue();
        int m = this.getMonth().getValue();
        int d = this.getDay().getValue();
        int sum = 0;
        int ynum = 0;
        int mnum = 0;
        if (this.getYear().isLeapYear()){
            a[2] = 29;
        }else {
            a[2]= 28;
        }
        if (new Year(y).isLeapYear()){
            ynum = 366;
        }else {
            ynum = 365;
        }
        int num = ynum - syts(this);//今年已有多少天
        //n天前不是本年
        if (n > num){
            n = n - num;
            y --;
            if (new Year(y).isLeapYear()){
                ynum = 366;
            }else {
                ynum = 365;
            }
            if (n > ynum){ //上某一年
                while (n-ynum >0){
                    if (new Year(y).isLeapYear()){
                        ynum = 366;
                    }else {
                        ynum = 365;
                    }
                    n=n-ynum;
                    y --;
                }
                int j = 0;
                if (new Year(y).isLeapYear()){
                    a[2] = 29;
                }else {
                    a[2] = 28;
                }
                for (j = 12; j > 0 && sum < n ; j --){
                    sum = sum + a[j];
                }
                m = j+1;
                d = sum - n ;

            }else {
                int j = 0;
                for (j = 12; j > 0 && sum < n ; j --){
                    sum = sum + a[j];
                }
                m = j+1;
                d = sum - n;
            }
        }else {     //n天前是本年
            if (n > d){ //不是本月
                n = n-d;
                int k = 0;
                for (k = m-1; k > 0 && sum < n ; k --){
                    sum = sum + a[k];
                }
                m = k + 1;
                d = sum - n;
            }else {
                d = d - n;
            }

        }
        return new DateUtil(y,m,d);
    }
    public int getDaysofDates(DateUtil date){
        DateUtil d1 = this;
        DateUtil d2 = date;
        int y1 = d1.getYear().getValue();
        int y2 = d2.getYear().getValue();
        int anum = 0;
        int bnum = 0;
        int ynum = 0;
        int sum = 0;
        anum = syts(d1);
        bnum = syts(d2);

        if (y1 > y2){
            if (new Year(y1).isLeapYear()){
                ynum = 366;
            }else {
                ynum = 365;
            }
            sum = sum + bnum + ynum -anum;
            y2++;
            while (y2 <= y1-1){
                if (new Year(y2).isLeapYear()){
                    ynum = 366;
                }else {
                    ynum = 365;
                }
                sum = sum + ynum;
                y2++;
            }
        }else if (y1 < y2) {
            if (new Year(y2).isLeapYear()){
                ynum = 366;
            }else {
                ynum = 365;
            }
            sum = sum + anum + ynum -bnum;
            y1++;
            while (y1 <= y2-1){
                if (new Year(y1).isLeapYear()){
                    ynum = 366;
                }else {
                    ynum = 365;
                }
                sum = sum + ynum;
                y1++;
            }
        }else {
            int m1 = d1.getMonth().getValue();
            int m2 = d2.getMonth().getValue();

            if (d1.getMonth().getValue() < d2.getMonth().getValue()){
                sum = d2.getDay().getValue() + d1.mon_maxnum[d1.getMonth().getValue()-1] - d1.getDay().getValue();
                m1++;
                while(m1 <= m2-1){
                    if (new Year(y1).isLeapYear()){
                        d1.mon_maxnum[1] = 29;
                    }else {
                        d1.mon_maxnum[1] = 28;
                    }
                    sum = sum + d1.mon_maxnum[m1-1];
                    m1++;
                }
            }else if (d1.getMonth().getValue() >d2.getMonth().getValue()){
                sum = d1.getDay().getValue() + d2.mon_maxnum[d2.getMonth().getValue()-1] - d2.getDay().getValue();
                m2++;
                while(m2 <= m1-1){
                    if (new Year(y1).isLeapYear()){
                        d1.mon_maxnum[1] = 29;
                    }else {
                        d1.mon_maxnum[1] = 28;
                    }
                    sum = sum + d2.mon_maxnum[m2-1];
                    m2++;
                }
            }else {
                if (d1.getDay().getValue() > d2.getDay().getValue()){
                    sum = d1.getDay().getValue() - d2.getDay().getValue();
                }else if (d1.getDay().getValue() < d2.getDay().getValue()){
                    sum = d2.getDay().getValue() - d1.getDay().getValue();
                }else {
                    sum = 0;
                }
            }
        }
        return sum;
    }
}

 

（1）7-2日期问题面对对象设计（聚合一）和7-5 日期问题面向对象设计（聚合二）两种日期类聚合设计的优劣比较： 

两道题的圈复杂度：两种日期聚合设计的圈复杂度差不多

 

两道题的类图：

 

题目7-2 日期问题面向对象设计（聚合一）是一层一层聚合，DateUtil与Day聚合，Day与Month聚合，Month与Year聚合。而题目7-5 日期问题面向对象设计（聚合二）是DateUtil分别与Day,Month,Year聚合。前者的访问方式是通过day的访问器方法一层一层访问，后者是直接访问DateUtil来调用。7-2的设计类间的关系更加紧密，但如果修改了其中一个类，其他类都会受到影响，修改起来工程更大。而7-5的设计修改起来更加方便，不需要修改所有的类，耦合度低。题目7-5是对题目7-2的改进。

（2）题目集4（7-3）、题目集6（7-5、7-6）三种渐近式图形继承设计的思路与技术运用（封装、继承、多态、接口等）

7-3 图形继承 (15 分)

编写程序，实现图形类的继承，并定义相应类对象并进行测试。

1. 类Shape，无属性，有一个返回0.0的求图形面积的公有方法public double getArea();//求图形面积
2. 类Circle，继承自Shape，有一个私有实型的属性radius（半径），重写父类继承来的求面积方法，求圆的面积
3. 类Rectangle，继承自Shape，有两个私有实型属性width和length，重写父类继承来的求面积方法，求矩形的面积
4. 类Ball，继承自Circle，其属性从父类继承，重写父类求面积方法，求球表面积，此外，定义一求球体积的方法public double getVolume();//求球体积
5. 类Box，继承自Rectangle，除从父类继承的属性外，再定义一个属性height，重写父类继承来的求面积方法，求立方体表面积，此外，定义一求立方体体积的方法public double getVolume();//求立方体体积
6. 注意：

• 每个类均有构造方法，且构造方法内必须输出如下内容：Constructing 类名
• 每个类属性均为私有，且必须有getter和setter方法（可用Eclipse自动生成）
• 输出的数值均保留两位小数

主方法内，主要实现四个功能（1-4）： 从键盘输入1，则定义圆类，从键盘输入圆的半径后，主要输出圆的面积； 从键盘输入2，则定义矩形类，从键盘输入矩形的宽和长后，主要输出矩形的面积； 从键盘输入3，则定义球类，从键盘输入球的半径后，主要输出球的表面积和体积； 从键盘输入4，则定义立方体类，从键盘输入立方体的宽、长和高度后，主要输出立方体的表面积和体积；

假如数据输入非法（包括圆、矩形、球及立方体对象的属性不大于0和输入选择值非1-4），系统输出Wrong Format

输入格式：

共四种合法输入

• 1 圆半径
• 2 矩形宽、长
• 3 球半径
• 4 立方体宽、长、高

输出格式：

按照以上需求提示依次输出

我的代码：

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int n = input.nextInt();
        if (n < 1 || n > 4){
            System.out.print("Wrong Format");
        }else {
            switch (n){
                case 1:
                    double radius = input.nextDouble();
                    if (Input(radius)){
                        Circle c = new Circle();
                        c.setRadius(radius);
                        System.out.printf("Circle's area:%.2f",c.getArea());
                    }
                    break;
                case 2:
                    double width = input.nextDouble();
                    double length = input.nextDouble();
                    if (Input(width) && Input(length)){
                        Rectangle r = new Rectangle();
                        r.setLength(length);
                        r.setWidth(width);
                        //System.out.printf("Rectangle's area:%.2f",r.getArea());
                        System.out.print(String.format("Rectangle's area:%.2f",r.getArea()));
                    }
                    break;
                case 3:
                    double radius1 = input.nextDouble();
                    if (Input(radius1)){
                        Ball b = new Ball();
                        b.setRadius(radius1);
                        System.out.printf("Ball's surface area:%.2f\n",b.getArea());
                        System.out.printf("Ball's volume:%.2f",b.getVolume());
                    }
                    break;
                case 4:
                    double width1 = input.nextDouble();
                    double length1 = input.nextDouble();
                    double height = input.nextDouble();
                    if (Input(width1) && Input(length1) && Input(height)){
                        Box box = new Box();
                        box.setWidth(width1);
                        box.setLength(length1);
                        box.setHeight(height);
                        System.out.printf("Box's surface area:%.2f\n",box.getArea());
                        System.out.printf("Box's volume:%.2f",box.getVolume());
                    }
                    break;
                default:break;
            }

            }

    }
    public static boolean Input(double n){
        if (n < 0 ) {
            System.out.print("Wrong Format");
            return false;
        }
        return true;
    }
}

class Shape{
    Shape() {
        System.out.println("Constructing Shape");
    }
    public double getArea(){
        return 0.0;
    }
}
class Circle extends Shape{

    private double radius;
    Circle(){
        System.out.println("Constructing Circle");
    }
    public double getRadius() {
        return radius;
    }
    public void setRadius(double radius) {
        this.radius = radius;
    }

    @Override
    public double getArea() {
        return radius * radius * Math.PI;
    }
}
class Rectangle extends Shape{
    private double width;
    private double length;
    public Rectangle(){
        System.out.println("Constructing Rectangle");
    }
    public double getWidth() {
        return width;
    }
    public void setWidth(double width) {
        this.width = width;
    }
    public double getLength() {
        return length;
    }
    public void setLength(double length) {
        this.length = length;
    }
    @Override
    public double getArea() {
        return width * length;
    }
}

class Ball extends Circle{
    public Ball(){
        System.out.println("Constructing Ball");
    }
    @Override
    public double getArea() {
        return 4.0 * Math.PI * super.getRadius() * super.getRadius();
    }
    public double getVolume(){
        return 4.0/3.0 * Math.PI * super.getRadius() * super.getRadius() * super.getRadius();
    }
}

class Box extends Rectangle{
    public Box(){
        System.out.println("Constructing Box");
    }
    private double height;

    public double getHeight() {
        return height;
    }
    public void setHeight(double height){
        this.height = height;
    }
    @Override
    public double getArea() {
        return ((super.getWidth() * super.getLength()) + (height * super.getWidth()) +(height * super.getLength())) * 2;
    }
    public double getVolume(){
        return super.getWidth() * super.getLength() * height;
        //return super.getArea() * height;
    }
}

 

7-5 图形继承与多态 (50 分)

掌握类的继承、多态性及其使用方法。具体需求参见作业指导书。

2021-OO第06次作业-5指导书V1.0.pdf

输入格式：

从键盘首先输入三个整型值（例如a b c），分别代表想要创建的Circle、Rectangle及Triangle对象的数量，然后根据图形数量继续输入各对象的属性值（均为实型数），数与数之间可以用一个或多个空格或回车分隔。

输出格式：

1. 如果图形数量非法（小于0）或图形属性值非法（数值小于0以及三角形三边关系），则输出Wrong Format。
2. 如果输入合法，则正常输出，输出内容如下（输出格式见输入输出示例）：

• 各个图形的面积；
• 所有图形的面积总和；
• 排序后的各个图形面积；
• 再次所有图形的面积总和。 

 我的代码：

import java.util.*;
import java.util.ArrayList;
public class Main {
    public static void main(String args[]) {
        Scanner input = new Scanner(System.in);
        ArrayList<Double>area = new ArrayList<Double>();
        int num1 = input.nextInt();
        int num2 = input.nextInt();
        int num3 = input.nextInt();
        if(num1 < 0 || num2 < 0 || num3 < 0 ){
            System.out.print("Wrong Format");
            System.exit(0);
        }
        Shape []c = new Circle[num1];
        Shape []r = new Rectangle[num2];
        Shape []t = new Triangle[num3];
        for (int i = 0 ; i < num1; i ++ ){
            double radius = input.nextDouble();
            c[i] = new Circle(radius);
            if(!c[i].validate()){
                System.out.print("Wrong Format");
                System.exit(0);
            }
            area.add(c[i].getArea());
        }
        for (int i = 0 ; i < num2; i ++ ){
            double width = input.nextDouble();
            double length = input.nextDouble();
            r[i] = new Rectangle(width,length);
            if(!r[i].validate()){
                System.out.print("Wrong Format");
                System.exit(0);
            }
            area.add(r[i].getArea());
        }
        for (int i = 0 ; i < num3; i ++ ){
            double side1 = input.nextDouble();
            double side2 = input.nextDouble();
            double side3 = input.nextDouble();
            t[i] = new Triangle(side1,side2,side3);
            if(!t[i].validate()){
                System.out.print("Wrong Format");
                System.exit(0);
            }
            area.add(t[i].getArea());
        }
        output(area);
        }

    public static String output(ArrayList<Double>area){
        System.out.println("Original area:");
        OpArea(area);
        OpSum(area);
        System.out.println("\nSorted area:");
        Collections.sort(area);
        OpArea(area);
        OpSum(area);
        return String.valueOf(true);
    }
    public static void OpArea(ArrayList<Double>area){
        for (int i = 0 ; i < area.size() ; i ++){
            System.out.printf("%.2f ",area.get(i));
        }
    }
    public static void OpSum(ArrayList<Double>area){
        double sum = 0;
        for (int i = 0 ; i < area.size() ; i ++){
            sum = area.get(i)+sum;
        }
        System.out.printf("\nSum of area:%.2f",sum);
    }

}
abstract class Shape{
    public abstract double getArea();
    public abstract boolean validate();
    public String toString(){
        return String.valueOf(true);
    }
}
//圆
class Circle extends Shape{
    double radius;
    Circle(double radius){
        this.radius = radius;
    }
    public double getRadius() {
        return radius;
    }
    public void setRadius(double radius) {
        this.radius = radius;
    }
    @Override
    public double getArea() {
        return this.radius * this.radius *Math.PI;
    }
    @Override
    public boolean validate(){
        return this.radius > 0;
    }
}
//矩形
class Rectangle extends Shape{
    double width;
    double length;
    Rectangle(double width , double length){
        this.width = width;
        this.length = length;
    }
    public double getWidth() {
        return width;
    }
    public void setWidth(double width) {
        this.width = width;
    }
    public double getLength() {
        return length;
    }
    public void setLength(double length) {
        this.length = length;
    }

    @Override
    public double getArea() {
        return this.width * this.length;
    }

    @Override
    public boolean validate() {
        return this.width > 0 && this.length > 0;
    }
}
//三角形
class Triangle extends Shape{
    double side1;
    double side2;
    double side3;
    Triangle(double side1,double side2,double side3){
        this.side1 = side1;
        this.side2 = side2;
        this.side3 = side3;
    }
    public double getSide1() {
        return side1;
    }
    public double getSide2() {
        return side2;
    }
    public double getSide3() {
        return side3;
    }
    public void setSide1(double side1) {
        this.side1 = side1;
    }
    public void setSide2(double side2) {
        this.side2 = side2;
    }
    public void setSide3(double side3) {
        this.side3 = side3;
    }

    @Override
    public double getArea() {
        double p = 0;
        p = (side1 + side2 + side3) / 2;
        return Math.sqrt(p * (p - side1) * (p - side2) * (p - side3));
    }

    @Override
    public boolean validate() {
        return (this.side1 > 0) && (this.side2 > 0) &&(this.side3 > 0) && (side1 + side2 > side3) && (side1 + side3 > side2) && (side2 + side3 > side1);
    }
}

 

7-6 实现图形接口及多态性 

编写程序，使用接口及类实现多态性，类图结构如下所示：

 

其中：

• GetArea为一个接口，无属性，只有一个GetArea（求面积）的抽象方法；
• Circle及Rectangle分别为圆类及矩形类，分别实现GetArea接口
• 要求：在Main类的主方法中分别定义一个圆类对象及矩形类对象（其属性值由键盘输入），使用接口的引用分别调用圆类对象及矩形类对象的求面积的方法，直接输出两个图形的面积值。（要求只保留两位小数）

输入格式：

从键盘分别输入圆的半径值及矩形的宽、长的值，用空格分开。

输出格式：

• 如果输入的圆的半径值及矩形的宽、长的值非法（≤0），则输出Wrong Format
• 如果输入合法，则分别输出圆的面积和矩形的面积值（各占一行），保留两位小数。

 我的代码：

import java.util.*;
public class Main {
    public static void main(String args[]) {
        Scanner input = new Scanner(System.in);
        double radius = input.nextDouble();
        double width = input.nextDouble();
        double length = input.nextDouble();
        if (radius <= 0 || width <=0 || length <= 0){
            System.out.print("Wrong Format");
            System.exit(0);
        }
        GetArea c = new Circle(radius);
        GetArea r = new Rectangle(width,length);
        System.out.printf("%.2f\n",c.getArea());
        System.out.printf("%.2f",r.getArea());
    }
}

interface GetArea{
    public abstract double getArea();
}
class Circle implements GetArea{
    double radius;
    Circle(){
    }
    Circle(double radius){
        this.radius = radius;
    }
    public double getRadius() {
        return radius;
    }
    public void setRadius(double radius) {
        this.radius = radius;
    }
    public double getArea(){
        return this.radius * this.radius * Math.PI;
    }
}
class Rectangle implements GetArea {
    double width;
    double length;
    Rectangle() {
    }
    Rectangle(double width, double length) {
        this.width = width;
        this.length = length;
    }

    public double getWidth() {
        return width;
    }
    public double getLength() {
        return length;
    }
    public void setWidth(double width) {
        this.width = width;
    }
    public void setLength(double length) {
        this.length = length;
    }
    public double getArea() {
        return this.width * this.length;
    }
}

 

 三种图形继承设计的报表：

 

由图可知，题目集4（7-3）的最大全圈复杂度18，平均圈复杂度1.73，题目集6（7-5）最大全圈复杂度10，平均圈复杂度2，题目集6（7-6）最大全圈复杂度4，平均圈复杂度1.23 。7-6的圈复杂度最低，7-3的圈复杂度最高。

三种图形继承设计的类图：

7-3

 7-4、7-5

 

 

题目集4（7-3）主要用的是类的封装与继承。Shape类中有一个有一个返回0.0的求图形面积的公有方法。Circle类继承Shape类，Rectangle类继承Shape类，Ball类继承Circle类，Box类继承自Rectangle。每个类都有构造方法，属性均为私有。Circle类和Rectangle类通过重写父类中的方法来求图形面积，Ball类和Box类通过重写父类的面积方法来求图形表面积。可以看出使用继承能提高效率，提高了代码的复用性。

题目集6（7-5）相比题目集4（7-3）多了多态的使用。采用的是抽象类定义、实体类构建的方式。Shape 为抽象类，其中包含抽象的求面积的方法，判断数据合理性的方法和将其他数据类型转换为字符串String类型的方法。Circle、Rectangle 及 Triangle 为实体类继承自Shape类，子类通过重写父类的抽象方法求图形面积。这道题运用了类的封装、继承与多态。

题目集6（7-6）中GetArea为一个接口，无属性，只有一个GetArea（求面积）的抽象方法，Circle及Rectangle分别实现GetArea接口，使用了接口中求面积的方法。这题主要体现了接口的使用。

（3）对三次题目集中用到的正则表达式技术的分析总结

题目集4（7-1 水文数据校验及处理）中运用到的正则表达式：

运用“\\|”将数据一个一个切割开来

Pattern p = Pattern.compile("\\|");

题目集5（7-4 统计Java程序中关键词的出现次数 ）中运用到的正则表达式：

这道题的正则表达式是这三个题目集中最难的也是最多的，要考虑输入源码中单行注释多行注释，字符串等情况。我先用正则表达式判断把输入案例中所有不是代码的剔除再进行关键字的判断。

//去掉字符串和单行注释
            str.append(s.replaceAll(".*//.*",""));

s = s.replaceAll("\"(.*?)\""," ");　　//去掉字符串
s = s.replaceAll("/\\*.*?\\*/"," ");　　//去掉/* */多行注释
s = s.replaceAll("\\p{P}"," ");　　//去掉所有标点符号
s = s.replaceAll("\\s+"," ");　　//去掉空白字符

题目集6（7-1 正则表达式训练-QQ号校验）中运用到的正则表达式：

Pattern p = Pattern.compile("^[1-9]{1}[\\d]{4,14}$");
        Matcher m = p.matcher(str);

题目集6（7-3 正则表达式训练-验证码校验）中运用到的正则表达式：

Pattern p = Pattern.compile("^([\\d]|[A-Z[a-z]]){4}$");
        Matcher m = p.matcher(str);

题目集6（7-4 正则表达式训练-学号校验）中运用到的正则表达式：

 Pattern p = Pattern.compile("^(2020){1}(1[1-7]|61|7[1-3]|8[1-2])([0-3][1-9]|40|30|20|10)$");
        Matcher m = p.matcher(str);

 题目集6中涉及的正则表达式较为简单，但在做题时也需考虑全面，不要漏了任何一种情况。

（4）题目集5（7-4）中Java集合框架应用的分析总结

7-4 统计Java程序中关键词的出现次数 (25 分)

编写程序统计一个输入的Java源码中关键字（区分大小写）出现的次数。说明如下：

• Java中共有53个关键字（自行百度）
• 从键盘输入一段源码，统计这段源码中出现的关键字的数量
• 注释中出现的关键字不用统计
• 字符串中出现的关键字不用统计
• 统计出的关键字及数量按照关键字升序进行排序输出
• 未输入源码则认为输入非法

输入格式：

输入Java源码字符串，可以一行或多行，以exit行作为结束标志

输出格式：

• 当未输入源码时，程序输出Wrong Format
• 当没有统计数据时，输出为空
• 当有统计数据时，关键字按照升序排列，每行输出一个关键字及数量，格式为数量\t关键字

 我的代码:

import java.util.*;
import java.util.regex.Pattern;
import java.util.Map;
import java.util.TreeMap;
public class Main {
    public static void main(String args[]) {
        Scanner input = new Scanner(System.in);
        int count;
        String[] key = {"abstract","assert","boolean","break","byte","case","catch",
                "char","class","const","continue","default","do","double","else",
                "enum","extends","false","final","finally","float",
                "for","goto","if","implements","import","instanceof",
                "int","interface","long","native","new","null","package",
                "private","protected","public","return","short","static",
                "strictfp","super","switch","synchronized","this","throw",
                "throws","transient","true","try","void","volatile","while"};

        Map<String,Integer>map = new TreeMap<String,Integer>();
        Set<Map.Entry<String,Integer>> entrySet = map.entrySet();
//        Iterator<Map.Entry<String,Integer>> iter = map.entrySet().iterator();
        String s ;
        StringBuilder str = new StringBuilder();
        while(!(s = input.nextLine().trim()).equals("exit")){
//            if(s.matches(".*//.*")){
//                continue;
//            };   //去掉字符串和单行注释
            str.append(s.replaceAll(".*//.*",""));
            str.append(" ");
        }
        s = str.toString();
        if(s.isEmpty()){
            System.out.println("Wrong Format");
            System.exit(0);
        }

        s = s.replaceAll("\"(.*?)\""," ");
        s = s.replaceAll("/\\*.*?\\*/"," ");
        s=s.replaceAll("\\p{P}"," ");
        s = s.replaceAll("\\s+"," ");
        Pattern p = Pattern.compile(" ");
        String[] st = p.split(s);
        for(int i = 0 ;i < st.length ; i ++){
            for(int j = 0 ; j < key.length ; j ++ ){
                if(st[i].equals(key[j])){
                    map.put(key[j],0);
                }
            }
        }
        for(int i = 0 ;i < st.length ; i ++){
            int j = 0;
            while(j < key.length){
                if(st[i].equals(key[j])){
                    count = map.get(key[j]);
                    map.put(key[j],count+1);
                }
                j++;
            }
        }
        for (Map.Entry<String,Integer> entry:map.entrySet()) {
            String s1 = entry.getKey();
            int n = entry.getValue();
            System.out.println(n+"\t"+s1);
        }
         System.exit(0);
    }

}

 

 

这里我主要运用的是map集合

Map：存储双列数据的集合，通过键值对存储数据，存储 的数据是无序的，Key值不能重复，value值可以重复。

由于输出关键字按升序排列，所以我选择的是TreeMap，下面是我在网上搜集到的使用方法：

TreeMjiap集合按照键是可排序不重复的键值对集合。(默认升序)
TreeMap集合按照键排序的特点与TreeSet是完全一样的。
TreeMap集合和TreeSet集合都是排序不重复集合
TreeSet集合的底层是基于TreeMap，只是键没有附属值而已。

三、踩坑心得

 下面是我在这几次作业中遇到的一些问题及学到的一些知识：

1、在题目集5（7-4 统计Java程序中关键词的出现次数 ）中，由于我的正则表达式有问题，去除多行注释的正则表达式考虑的不全面，最后一个测试点一直过不去。

修改前：

   s = s.replaceAll("/\\（*.*）?\\*/"," ");

修改后：

   s = s.replaceAll("/\\*.*?\\*/"," ");

2、在题目集6（7-5 图形继承与多态 ）中要求将面积排序后输出，我用到了ArrayList 数组，下面是我的笔记：

ArrayList 继承了 AbstractList ，并实现了 List 接口。

 

ArrayList 类是一个可以动态修改的数组，与普通数组的区别就是它是没有固定大小的限制，我们可以添加或删除元素。
ArrayList常用方法：

add() 　　　　 将元素插入到指定位置的 arraylist 中
addAll() 　　    添加集合中的所有元素到 arraylist 中
clear()　　 　   删除 arraylist 中的所有元素
get() 　　　　  通过索引值获取 arraylist 中的元素
remove() 　　  删除 arraylist 里的单个元素
size() 　　　　 返回 arraylist 里元素数量
isEmpty() 　　  判断 arraylist 是否为空
set() 　　　　   替换 arraylist 中指定索引的元素
sort() 　　　　  对 arraylist 元素进行排序
toArray() 　　   将 arraylist 转换为数组
toString() 　　  将 arraylist 转换为字符串
forEach() 　　  遍历 arraylist 中每一个元素并执行特定操作

四、改进建议

 1、在题目集4（7-1 水文数据校验及处理 ）中由于有些方法我当时没有理解意思，有些方法没有用到，于是做了以下改进：getDealDateResult()方法用来获取结果，computeData()方法用来计算数据。

 

public void getDealDateResult(){
        String[] inValue = this.sb.split("\n");
        int i=0;
        while(i<inValue.length){
            CheckData inputCheck = new CheckData(inValue[i],i+1);
            if(inputCheck.validateData()){
                hydrologicalInfo[i] = inputCheck.toHydrologicalInfo();
            }
            i++;
        }
        this.computeData(hydrologicalInfo);

    }
 public void computeData(HydrologicalInfo hydrologicalInfo[]){
        int i=0;
        double maxWaterLevel = hydrologicalInfo[0].getActualWaterLevel();
        double totalFlow = 0;
        while(hydrologicalInfo[i]!=null){
            if(hydrologicalInfo[i].getActualGateOpening()>hydrologicalInfo[i].getObjectGateOpening()){
                System.out.println("Row:"+(i+1)+" GateOpening Warning");
            }
            if(hydrologicalInfo[i].getActualWaterLevel()>maxWaterLevel){
                maxWaterLevel = hydrologicalInfo[i].getActualWaterLevel();
            }
            totalFlow += 2*60*60*hydrologicalInfo[i].getWaterFlow();
            i++;
        }
        System.out.printf("Max Actual Water Level:%.2f\n",maxWaterLevel);
        System.out.printf("Total Water Flow:%.2f\n",totalFlow);
    }

 2、在题目集4（7-2 日期问题面向对象设计（聚合一））中，我的求下一天方法较为复杂，且dayIncrement()、resetMin()、monthIncrement()等方法未用到，于是在同学的提示下做了以下改进：

改进前：

    public DateUtil getNextNdays(int n){
        int a[] = {0,31,28,31,30,31,30,31,31,30,31,30,31};
        int y = this.getDay().getMonth().getYear().getValue();
        int m = this.getDay().getMonth().getValue();
        int d = this.getDay().getValue();
        int sum = 0;
        int num = syts(this);
        int ynum = 0;
        int mnum = 0;
        if (this.getDay().getMonth().getYear().isLeapYear()){
            a[2] = 29;
        }else {
            a[2]= 28;
        }
        if (n > num){//n大于本年剩余天数
            n = n - num;
            y ++;
            if (new Year(y).isLeapYear()){
                ynum = 366;
            }else {
                ynum = 365;
            }
            //大于本年剩余天数但小于下一年天数
            if(n < ynum){
                int i = 0;
                for (i = 0 ;i < 12 && sum < n; i++){
                    sum = sum + a[i];
                }
                m = i-1;
                d = n - sum + a[i-1] ;
            }else if (n > ynum){//大于本年剩余天数且大于下一年天数
                int j = 0;
                while (n-ynum > 0){
                    if (new Year(y).isLeapYear()){
                        ynum = 366;
                    }else {
                        ynum = 365;
                    }
                    n=n-ynum;
                    y ++;
                }
                for (j = 0; j < 12 && sum < n ; j ++){
                    sum = sum + a[j];
                }
                m = j-1;
                d = n - sum + a[j-1] ;
            }

        }else { //小于本年剩余天数
            int k = 0;
            mnum = a[m]-d;
            if (n <= mnum){  //小于本月剩余天数
                d = d + n;
            }else {
                n = n - mnum;
                for (k = m+1;k <= 12 && sum < n ; k ++){
                    sum = sum + a[k];
                }
                m = k-1;
                d = n - sum + a[k-1] ;
            }
        }
        return new DateUtil(y,m,d);
    }

改进后：

 public DateUtil getNextNDays(int n) {
        int countDays = 0;
        while (countDays < n) {
            this.day.dayIncrement();
            countDays++;
            if (this.day.getMonth().getYear().isLeapYear()) {
                this.day.mon_maxnum[1] = 29;
            }else {
                this.day.mon_maxnum[1] = 28;
            }
            if (this.day.getValue() > this.day.mon_maxnum[this.day.getMonth().getValue() - 1]) {
                this.day.getMonth().monthIncrement();//月份加1
                if (this.day.getMonth().getValue() > 12) {//月份累加大于12
                    this.day.getMonth().getYear().yearIncrement();//年份加1
                    this.day.getMonth().resetMin();//月份归1
                }
                this.day.resetMin();//天数归1
            }
        }
        return this;
    }

 

五、总结

通过这几次作业，我对Java三大特性：封装、继承和多态有了更深入的理解，正则表达式的运用也更加熟练。

封装只能通过规定的方法访问数据，将事物拥有的属性和动作隐藏起来，只保留特定的方法与外界联系。当内部的逻辑发生变化时，外部调用不用因此而修改，它们只调用开放的接口，而不用去关心内部的实现，方便修改和实现。

继承是面向对象的最显著的一个特征。子类拥有父类非private的属性和方法，子类可以添加自己的方法和属性，即对父类进行扩展，子类可以重新定义父类的方法，即方法的覆盖/重写。父类的构造函数不能被继承，子类可以通过super()显示调用父类的构造函数。创建子类时，编译器会自动调用父类的无参构造函数。super关键字可以从子类访问父类中的内容。

多态有三个条件：1、继承：在多态中必须存在有继承关系的子类和父类；2、重写：子类对父类中某些方法进行重新定义，在调用这些方法时就会调用子类的方法；3、向上转型：在多态中需要将子类的引用赋给父类对象，只有这样该引用才既能可以调用父类的方法，又能调用子类的方法。

还了解到抽象类的使用，抽象方法没有方法体，抽象方法必须存在于抽象类中，子类重写父类时，必须重写父类所有的抽象方法。