题目集4~6总结

一.前言

1.题目集4：

（1）     知识点：正则表达式，聚合，继承

（2）     题量：虽然只有三个题，但难度较大，所以相对来说比较合适

（3）     难度：因为对正则表达式掌握还不熟练，以及对聚合和继承的理解还不到位，所以此次题目集难度偏难；但主要是第一题较复杂，第二题只要看懂类图，理解各个类的关系之后便大致可以写出。

2.题目集5：

（1）     知识点：字符串分割，排序，正则表达式，继承

（2）     题量：虽然有5个题，但难度不大，所以相对合适

（3）     难度：此次题目集大多为之前做过的题，除了第四题难度较大以外，其他题难度都偏小。

3.题目集6：

（1）     知识点：正则表达式，继承，多态，接口

（2）     题量：虽然有5个题，但难度适中，所以相对合适

（3）     难度：此题目集大多为基本的正则表达式的运用和基本的排序，除了最后两道题以外难度都不大，且最后两道题也是之前做过的题目的变形，题目大同小异，所以难度适中。

二．设计与分析:

  ①题目集4（7-2）、题目集5（7-5）两种日期类聚合设计的优劣比较:

      题目集4（7-2）日期问题面向对象设计（聚合一）：

参考题目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且输入均有效，输出格式如下：

  天数值

测试结果：

 

 

 

 

 

 

 

 

        分析：此题只要看懂类图则难度不大，若没看懂可能有些绕。我刚开始做这题时，也是没有看懂类图，有些烧脑，但后来慢慢理解发现其实很简单。

          在这里主要运用了聚合关系（【聚合关系】：是整体与部分的关系，且部分可以离开整体而单独存在。如车和轮胎是整体和部分的关系，轮胎离开车仍然可以存在。聚合关系是关联关系的一种，是强的关联关系；关联和聚合在语法上无法区分，必须考察具体的逻辑关系。）更多类的关系点击这里哦

        在理清类与类的关系后，其难点在与其功能的实现。

1. 求下n天：首先要判断当前年份是否是闰年，如果是闰年则二月为29天，若不是则28天。然后调用day.dayIncrement()方法进行日期的增1，如果增1后达到了当前月份的最大天数，则月份增1，并使用day.resetMin()方法进行日期复位成1号，如果月份增1后变为13，则年份增1 ，并使用day.month.resetMin()进行月份复位成1月，直到增加了指定的n天。（PS：此题测试点有考虑到一个效率问题，所以要在方法开始时增加

   int t=n/146097;
   day.month.year.value= day.month.year.value+t*400;这两行代码，其中146097是400年的总天数，如果n超过146097，则进行缩减来提搞效率）

2. 求前n天：大致思路同上。
3. 求两个日期相差的天数：我的大致思路是，把年月日拆开进行计算，先算年与年之间相差的天数m（这里要注意闰年的问题），而后将每个日期的月份所包含的天数进行计算再加上日的天数得到n1,n2，将得到的n1,n2进行求差(根据大小关系判断是n1-n2还是n2-n1)然后再加上m即可。

import java.util.Scanner;

class Dateutil{
    Day day;
    int flag=0;
    public Dateutil() {
        
    }
    public Dateutil(int d,int m,int y) {
        this.day = new Day(y,m,d);
        /*day.month.year.value=y;
           day.month.value=m;
           day.value=d;*/
            
    }
    public void setDay(Day d)
    {
        this.day=d;
        
    }
    public Day getDay()
    {
        return day;
    }
    
    public boolean checkInputValidity()
    {
        if(day.validate()&&day.month.validate()&&day.month.year.validate())
            return true;
        else
            return false;
    }
    public boolean compareDates(Dateutil date)
    {
        if(day.month.year.value>date.day.month.year.value)
            return true;
        else if(day.month.year.value==date.day.month.year.value)
        {
            if(day.month.value>date.day.month.value)
                return true;
            else if(day.month.value==date.day.month.value)
            {
                if(day.value>date.day.value)
                   return true;
                else if(day.value<date.day.value)
                   return false;
            }
            else 
            {
                return false;
            }
        }
        else 
        {
            return false;
        }
        return false;
    }
    public boolean equalTwoDates(Dateutil date)
    {
        if(day.month.year.value==date.day.month.year.value&&day.month.value==date.day.month.value&&day.value==date.day.value)
            return true;
        else
            return false;
    }
    public String showDate()
    {
        String abc=null;
        abc=String.format("%d-%d-%d",day.month.year.value,day.month.value,day.value);
        return abc;
    }
    public Dateutil getNextNDays(int n)
    {
          int i=0;
          while(i!=n)
          {
              if(day.month.year.isLeapYear())
                {
                 day.mon_maxnum[1]=29;
                }
                else
                {
                    day.mon_maxnum[1]=28;
                }
           day.dayIncrement();
           if(day.value==day.mon_maxnum[day.month.value-1]+1)
           {
               day.month.value++;
               day.resetMin();
           }
           if(day.month.value==13)
           {
               day.month.year.value++;
               day.month.resetMin();
           }
           i++;
          }
        return null;
    }
    public Dateutil getpreviousNDays(int n)
    { 
        
       int i=0;
       while(i!=n)
       {
           if(day.month.year.isLeapYear())
              {
               day.mon_maxnum[1]=29;
              }
              else
              {
                  day.mon_maxnum[1]=28;
              }
        day.dayReduction();
        if(day.value==0)
        {
           day.month.value--;

             if(day.month.value==0)
             {
                 day.month.year.value--;
                 day.month.resetMax();
             }
           day.resetMax();
        }
        i++;
       }
        return null;
    }
    public int getDaysofDates(Dateutil date)
    {
        int x=0,y1 = 0,y2=0,z1=0,z2=0,m=0,n=0;
        
        if(equalTwoDates(date))
        {
            return 0;
        }
        else
        {
                  //2020.1.1
                //2019.12.31
                if(compareDates(date)) {
                    //前大
                    x=Math.abs(day.month.year.value-date.day.month.year.value);
                    m=x/4;
                    if (date.day.month.year.value == 1900 && !date.compareDates(new Dateutil(1900,2,28))) {
                        m--;
                    }
                    for(int i=0;i<day.month.value-1;i++)
                    {
                        y1=y1+day.mon_maxnum[i];
                    }
                    for(int i=0;i<date.day.month.value-1;i++)
                    {
                        y2=y2+date.day.mon_maxnum[i];
                    }
                    z1=y1+day.value;//1
                    z2=y2+date.day.value;//365
                    n=365*x+m+(z1-z2);
                    //System.out.print(z1 + "&" + z2);
                }else {
                    x=Math.abs(day.month.year.value-date.day.month.year.value);
                    m=x/4;

                    if (day.month.year.value == 1900 && !compareDates(new Dateutil(1900,2,28))) {
                        m--;
                    }
                    for(int i=0;i<day.month.value-1;i++)
                    {
                        y1=y1+day.mon_maxnum[i];
                    }
                    for(int i=0;i<date.day.month.value-1;i++)
                    {
                        y2=y2+date.day.mon_maxnum[i];
                    }
                    z1=y1+day.value;//365
                    z2=y2+date.day.value;//1
                    n=365*x+m+(z2-z1);
                }
                
            
        }
        return n;
    }
}

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);
               //month.year.value=yearValue;
               //month.value=monthValue;
               this.value=dayValue;
               
    
    }
    public void setValue(int value)
    {
        this.value=value;
    }
    public int getValue()
    {
        return value;
    }
    public void setMonth(Month value)
    {
        this.month=value;
    }
    public Month getMonth()
    {
        return month;
    }
   public void  resetMin()
   {
       value=1;
   }
   public void  resetMax()
   {
       value=mon_maxnum[month.value-1];
   }
   public boolean validate()
   {
        if(value<1||value>31)
            return false;
        else 
        {
            if(month.year.isLeapYear())
            {
              if((month.value==2&&value>29)||(month.value==4&&value>30)||(month.value==6&&value>30)||(month.value==9&&value>30)||(month.value==11&&value>30))
                  return false;
              
            }
            else
            {
              if((month.value==2&&value>28)||(month.value==4&&value>30)||(month.value==6&&value>30)||(month.value==9&&value>30)||(month.value==11&&value>30))
                  return false;
            }
        }
        return true;
   }
   public void dayIncrement()
   {
       value=value+1;
   }
   public void dayReduction()
   {
       value=value-1;
   }
   
}
class Month
{
    int value;
    Year year;
    public Month()
    {
        
    }
    public Month(int yearValue,int monthValue)
    {
        this.year= new Year(yearValue);
        //year.value=yearValue;
        this.value=monthValue;
    }
    public void setValue(int value)
    {
        this.value=value;
    }
    public int getValue()
    {
        return value;
    }
    public void setYear(Year year)
    {
        this.year=year;
    }
    public Year getyear()
    {
        return year;
    }
    public void  resetMin()
    {
        value=1;
    }
    public void  resetMax()
    {
        value=12;
    }
    public boolean validate()
    {
        if(value<1||value>12)
            return false;
        else
             return true;
    }
    public void monthIncrement()
    {
        value=value+1;
    }
    public void monthReduction()
    {
        value=value-1;
    } 
}
class Year{
    int value;
    public Year()
    {}
    public Year(int value)
    {
        this.value=value;
    }
    public void setvalue(int value)
    {
        this.value=value;
    }
    public int getvalue()
    {
        return value;
    }
    
     public  boolean isLeapYear()
        {
            if((value%4==0)&&(value%100!=0)||value%400==0)
            return true;
            return false;
        }
     public  boolean validate()
        {
            
            if(value<1900||value>2050)
                return false;
            else
                return true;
        }
     public void yearIncrement()
     {
         value = value+1;
     }
     public void yearReduction()
     {
         value = value-1;
     }
}
public class Main {
    public static void main(String[] args) {
        Scanner in =  new Scanner(System.in);
        int m;
        m=in.nextInt();
        switch(m)
        {
        case 1:
            int year=in.nextInt();
            int month=in.nextInt();
            int day=in.nextInt();
            int n=in.nextInt();
            Dateutil abc =new Dateutil(day,month,year);
            if(abc.checkInputValidity())
            {
                abc.getNextNDays(n);
                System.out.println(abc.showDate());
            }
            else
            {
                System.out.println("Wrong Format");
            }
            break;
        case 2:
            int year2=in.nextInt();
            int month2=in.nextInt();
            int day2=in.nextInt();
            int n2=in.nextInt();
            Dateutil abc2 =new Dateutil(day2,month2,year2);
            if(abc2.checkInputValidity())
            {
                abc2.getpreviousNDays(n2);
                System.out.println(abc2.showDate());
            }
            else
            {
                System.out.println("Wrong Format");
            }
            break;
        case 3:
            int year3=in.nextInt();
            int month3=in.nextInt();
            int day3=in.nextInt();
            int year4=in.nextInt();
            int month4=in.nextInt();
            int day4=in.nextInt();
            Dateutil abc3 = new Dateutil(day3,month3,year3);
            Dateutil date = new Dateutil(day4,month4,year4);
            if(abc3.checkInputValidity()&&date.checkInputValidity())
            {
            System.out.println(abc3.getDaysofDates(date));
            }
            else
            {
                System.out.println("Wrong Format");
            }
            break;
        default:
           System.out.println("Wrong Format");
        }
    }
    }

 

 题目集5（7-5）日期问题面向对象设计（聚合二）:

参考题目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:值

        测试结果：同上。

        此题与上题思路基本相同，不同点在与类与类之间的关系不同。

       题目集4（7-2）:运用了聚合关系，部分与整体的关系密切，类与类之间的关系更为紧密，但代码实现更为繁琐。

       题目集5（7-4）：直接调用相应类中的属性和方法，但代码实现更简洁容易。

import java.util.Scanner;

class Dateutil{
    Day day;
    int flag=0;
    public Dateutil() {
        
    }
    public Dateutil(int d,int m,int y) {
        this.day = new Day(y,m,d);
        /*day.month.year.value=y;
           day.month.value=m;
           day.value=d;*/
            
    }
    public void setDay(Day d)
    {
        this.day=d;
        
    }
    public Day getDay()
    {
        return day;
    }
    
    public boolean checkInputValidity()
    {
        if(day.validate()&&day.month.validate()&&day.month.year.validate())
            return true;
        else
            return false;
    }
    public boolean compareDates(Dateutil date)
    {
        if(day.month.year.value>date.day.month.year.value)
            return true;
        else if(day.month.year.value==date.day.month.year.value)
        {
            if(day.month.value>date.day.month.value)
                return true;
            else if(day.month.value==date.day.month.value)
            {
                if(day.value>date.day.value)
                   return true;
                else if(day.value<date.day.value)
                   return false;
            }
            else 
            {
                return false;
            }
        }
        else 
        {
            return false;
        }
        return false;
    }
    public boolean equalTwoDates(Dateutil date)
    {
        if(day.month.year.value==date.day.month.year.value&&day.month.value==date.day.month.value&&day.value==date.day.value)
            return true;
        else
            return false;
    }
    public String showDate()
    {
        String abc=null;
        abc=String.format("%d-%d-%d",day.month.year.value,day.month.value,day.value);
        return abc;
    }
    public Dateutil getNextNDays(int n)
    {
          int i=0;
          while(i!=n)
          {
              if(day.month.year.isLeapYear())
                {
                 day.mon_maxnum[1]=29;
                }
                else
                {
                    day.mon_maxnum[1]=28;
                }
           day.dayIncrement();
           if(day.value==day.mon_maxnum[day.month.value-1]+1)
           {
               day.month.value++;
               day.resetMin();
           }
           if(day.month.value==13)
           {
               day.month.year.value++;
               day.month.resetMin();
           }
           i++;
          }
        return null;
    }
    public Dateutil getpreviousNDays(int n)
    { 
        
       int i=0;
       while(i!=n)
       {
           if(day.month.year.isLeapYear())
              {
               day.mon_maxnum[1]=29;
              }
              else
              {
                  day.mon_maxnum[1]=28;
              }
        day.dayReduction();
        if(day.value==0)
        {
           day.month.value--;

             if(day.month.value==0)
             {
                 day.month.year.value--;
                 day.month.resetMax();
             }
           day.resetMax();
        }
        i++;
       }
        return null;
    }
    public int getDaysofDates(Dateutil date)
    {
        int x=0,y1 = 0,y2=0,z1=0,z2=0,m=0,n=0;
        
        if(equalTwoDates(date))
        {
            return 0;
        }
        else
        {
                  //2020.1.1
                //2019.12.31
                if(compareDates(date)) {
                    //前大
                    x=Math.abs(day.month.year.value-date.day.month.year.value);
                    m=x/4;
                    if (date.day.month.year.value == 1900 && !date.compareDates(new Dateutil(1900,2,28))) {
                        m--;
                    }
                    for(int i=0;i<day.month.value-1;i++)
                    {
                        y1=y1+day.mon_maxnum[i];
                    }
                    for(int i=0;i<date.day.month.value-1;i++)
                    {
                        y2=y2+date.day.mon_maxnum[i];
                    }
                    z1=y1+day.value;//1
                    z2=y2+date.day.value;//365
                    n=365*x+m+(z1-z2);
                    //System.out.print(z1 + "&" + z2);
                }else {
                    x=Math.abs(day.month.year.value-date.day.month.year.value);
                    m=x/4;

                    if (day.month.year.value == 1900 && !compareDates(new Dateutil(1900,2,28))) {
                        m--;
                    }
                    for(int i=0;i<day.month.value-1;i++)
                    {
                        y1=y1+day.mon_maxnum[i];
                    }
                    for(int i=0;i<date.day.month.value-1;i++)
                    {
                        y2=y2+date.day.mon_maxnum[i];
                    }
                    z1=y1+day.value;//365
                    z2=y2+date.day.value;//1
                    n=365*x+m+(z2-z1);
                }
                
            
        }
        return n;
    }
}

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);
               //month.year.value=yearValue;
               //month.value=monthValue;
               this.value=dayValue;
               
    
    }
    public void setValue(int value)
    {
        this.value=value;
    }
    public int getValue()
    {
        return value;
    }
    public void setMonth(Month value)
    {
        this.month=value;
    }
    public Month getMonth()
    {
        return month;
    }
   public void  resetMin()
   {
       value=1;
   }
   public void  resetMax()
   {
       value=mon_maxnum[month.value-1];
   }
   public boolean validate()
   {
        if(value<1||value>31)
            return false;
        else 
        {
            if(month.year.isLeapYear())
            {
              if((month.value==2&&value>29)||(month.value==4&&value>30)||(month.value==6&&value>30)||(month.value==9&&value>30)||(month.value==11&&value>30))
                  return false;
              
            }
            else
            {
              if((month.value==2&&value>28)||(month.value==4&&value>30)||(month.value==6&&value>30)||(month.value==9&&value>30)||(month.value==11&&value>30))
                  return false;
            }
        }
        return true;
   }
   public void dayIncrement()
   {
       value=value+1;
   }
   public void dayReduction()
   {
       value=value-1;
   }
   
}
class Month
{
    int value;
    Year year;
    public Month()
    {
        
    }
    public Month(int yearValue,int monthValue)
    {
        this.year= new Year(yearValue);
        //year.value=yearValue;
        this.value=monthValue;
    }
    public void setValue(int value)
    {
        this.value=value;
    }
    public int getValue()
    {
        return value;
    }
    public void setYear(Year year)
    {
        this.year=year;
    }
    public Year getyear()
    {
        return year;
    }
    public void  resetMin()
    {
        value=1;
    }
    public void  resetMax()
    {
        value=12;
    }
    public boolean validate()
    {
        if(value<1||value>12)
            return false;
        else
             return true;
    }
    public void monthIncrement()
    {
        value=value+1;
    }
    public void monthReduction()
    {
        value=value-1;
    } 
}
class Year{
    int value;
    public Year()
    {}
    public Year(int value)
    {
        this.value=value;
    }
    public void setvalue(int value)
    {
        this.value=value;
    }
    public int getvalue()
    {
        return value;
    }
    
     public  boolean isLeapYear()
        {
            if((value%4==0)&&(value%100!=0)||value%400==0)
            return true;
            return false;
        }
     public  boolean validate()
        {
            
            if(value<1900||value>2050)
                return false;
            else
                return true;
        }
     public void yearIncrement()
     {
         value = value+1;
     }
     public void yearReduction()
     {
         value = value-1;
     }
}
public class Main {
    public static void main(String[] args) {
        Scanner in =  new Scanner(System.in);
        int m;
        m=in.nextInt();
        switch(m)
        {
        case 1:
            int year=in.nextInt();
            int month=in.nextInt();
            int day=in.nextInt();
            int n=in.nextInt();
            Dateutil abc =new Dateutil(day,month,year);
            if(abc.checkInputValidity())
            {
                abc.getNextNDays(n);
                System.out.println(abc.showDate());
            }
            else
            {
                System.out.println("Wrong Format");
            }
            break;
        case 2:
            int year2=in.nextInt();
            int month2=in.nextInt();
            int day2=in.nextInt();
            int n2=in.nextInt();
            Dateutil abc2 =new Dateutil(day2,month2,year2);
            if(abc2.checkInputValidity())
            {
                abc2.getpreviousNDays(n2);
                System.out.println(abc2.showDate());
            }
            else
            {
                System.out.println("Wrong Format");
            }
            break;
        case 3:
            int year3=in.nextInt();
            int month3=in.nextInt();
            int day3=in.nextInt();
            int year4=in.nextInt();
            int month4=in.nextInt();
            int day4=in.nextInt();
            Dateutil abc3 = new Dateutil(day3,month3,year3);
            Dateutil date = new Dateutil(day4,month4,year4);
            if(abc3.checkInputValidity()&&date.checkInputValidity())
            {
            System.out.println(abc3.getDaysofDates(date));
            }
            else
            {
                System.out.println("Wrong Format");
            }
            break;
        default:
           System.out.println("Wrong Format");
        }
    }
    }

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

  1. 题目集4（7-3）图形继承 ：

 

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

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 立方体宽、长、高

输出格式:

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

测试结果;

 

 

 

 

    分析：此题主要运用了封装与继承。若能基本掌握继承，则本题难度不大。

              继承：（点击此处了解更多）         

                      1.继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

                       2.继承的作用：通过继承可以快速创建新的类，实现代码的重用，提高程序的可维护性，节省大量创建新类的时间，提高开发效率和开发质量。

               首先，定义一个Shape类作为父类，之后定义的Circle，Rectangle都继承自Shape类并定义各自的私有属性和方法，而后的类Ball，继承自Circle，类Box，继承自Rectangle并定义或继承各自的私有属性和方法。

       PS ：1.由于会在计算中使用Π，所以在使用时不能直接使用3.14来计算，而是用Math.PI来进行计算。

                 2.结果会保留两位小数，所以在计算球的体积时应使用4 / 3.0 * Math.PI * getradius() * getradius() * getradius()而不是4 / 3 * Math.PI * getradius() * getradius() * getradius()来计算。

import java.math.BigInteger;
import java.text.DecimalFormat;
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

class Shape {
    public Shape() {
        System.out.println("Constructing Shape");
    }

    public double getArea() {
        return 0.0;

    }
}

class Circle extends Shape {
    private double radius;

    public Circle(double radius) {
        this.radius = radius;
        System.out.println("Constructing Circle");
    }

    
    public void setradius(double radius) {
        this.radius = radius;
    }

    public double getradius() {
        return radius;
    }

    public double getArea() {
        double CircleArea;
        CircleArea = Math.PI * getradius() * getradius();
        return CircleArea;
    }
}

class Rectangle extends Shape {
    public Rectangle(double width, double length) {
        this.width = width;
        this.length = length;
        System.out.println("Constructing Rectangle");
    }

    private double width;
    private double length;

    public void setwidth(double width) {
        this.width = width;
    }

    public double getwidth() {
        return width;
    }

    public void setlength(double length) {
        this.length = length;
    }

    public double getlength() {
        return length;
    }

    public double getArea() {

        double Rectangle;
        Rectangle = getwidth() * getlength();
        return Rectangle;
    }
}

class Ball extends Circle {
    public Ball(double radius) {
        super(radius);
        System.out.println("Constructing Ball");
    }

    public double getArea() {

        double BallArea;
        BallArea = 4 * Math.PI * getradius() * getradius();
        return BallArea;
    }

    public double getVolume() {
        double BallVolume;
        BallVolume = 4 / 3.0 * Math.PI * getradius() * getradius() * getradius();
        return BallVolume;
    }
}

class Box extends Rectangle {
    public Box(double width, double length, double height) {
        super(width, length);
        this.height = height;
        System.out.println("Constructing Box");
    }

    private double height;

    public void setheight(double height) {
        this.height = height;
    }

    public double getheight() {
        return height;
    }

    public double getArea() {
        double BoxArea;
        BoxArea = (getwidth() * getlength() + getwidth() * getheight() + getlength() * getheight()) * 2;
        return BoxArea;
    }

    public double getVolume() {
        double BoxVolume;
        BoxVolume = getwidth() * getlength() * getheight();
        return BoxVolume;
    }
}

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int flag = 0;
        DecimalFormat df = new DecimalFormat("0.00");
        switch (n) {
        case 1:
            double radius1 = in.nextDouble();
            if (radius1 <= 0) {
                flag = 1;
                break;
            }

            Circle circle = new Circle(radius1);

            circle.setradius(radius1);
            System.out.println("Circle's area:" + df.format(circle.getArea()));
            break;
        case 2:
            double width1 = in.nextDouble();
            double length1 = in.nextDouble();
            if (width1 <= 0 || length1 <= 0) {
                flag = 1;
                break;
            }

            Rectangle rectangle = new Rectangle(width1, length1);

            rectangle.setwidth(width1);
            rectangle.setlength(length1);
            System.out.println(
                    "Rectangle's area:" + df.format(rectangle.getArea()));
            break;
        case 3:
            double radius2 = in.nextDouble();
            if (radius2 <= 0) {
                flag = 1;
                break;
            }

            Ball ball = new Ball(radius2);

            ball.setradius(radius2);
            System.out.println("Ball's surface area:" + df.format(ball.getArea()));
            System.out.println("Ball's volume:" + df.format(ball.getVolume()));
            break;
        case 4:
            double width2 = in.nextDouble();
            double length2 = in.nextDouble();
            double height = in.nextDouble();
            if (width2 <= 0 || length2 <= 0 || height <= 0) {
                flag = 1;
                break;
            }

            Box box = new Box(width2, length2, height);

            box.setwidth(width2);
            box.setlength(length2);
            box.setheight(height);
            System.out.println(
                    "Box's surface area:" + df.format(box.getArea()));
            System.out.println(
                    "Box's volume:" + df.format(box.getVolume()));
            break;

        default:
            flag = 1;
            break;
        }
        if (flag == 1)
            System.out.println("Wrong Format");

    }
}

 

2.题目集6（7-5）图形继承与多态：

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

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

输入格式:

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

输出格式:

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

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

 测试结果：

 

 

 

 

 

 

分析：

类图如下：

 

            根据类图我们可以明白类与类之间的关系，之后再书写代码

            此题各个类的继承与上题大致相同并在继承的基础上增加了多态，容易踩坑的地方在于对三角形合理性的判断（此判断在上个博客中有提到）

多态：（想了解更多点击此处）          

1.多态是继封装、继承之后，面向对象的第三大特性。

2.多态现实意义理解：

       现实事物经常会体现出多种形态，如学生，学生是人的一种，则一个具体的同学张三既是学生也是人，即出现两种形态。                                                                                                            Java作为面向对象的语言，同样可以描述一个事物的多种形态。如Student类继承了Person类，一个Student的对象便既是Student，又是Person。

3.多态体现为父类引用变量可以指向子类对象。

4.前提条件：必须有子父类关系。

    注意：在使用多态后的父类引用变量调用方法时，会调用子类重写后的方法。

5.多态的定义与使用格式

                   定义格式：父类类型 变量名=new 子类类型();

6.理解:

               多态是同一个行为具有多个不同表现形式或形态的能力。

               多态就是同一个接口，使用不同的实例而执行不同操作

import java.text.DecimalFormat;
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
class shape
{
    public shape()
    {
        
    }
    public double getarea()
    {
        return 0.0;
    }
}
class Circle extends shape
{
    public Circle(double r)
    {
        this.r=r;
    }
    
    private double r;
    public void setr(double r)
    {
        this.r=r;
    }
    public double getr()
    {
        return r;
    }
    
    public double getArea()
    {
        double Circlearea=Math.PI*r*r;
        return Circlearea;
    }
}
class Rectangle extends shape
{
    public Rectangle(double width, double length) {
        this.width = width;
        this.length = length;
    }

    private double width;
    private double length;
    public void setwidth(double width) {
        this.width = width;
    }

    public double getwidth() {
        return width;
    }

    public void setlength(double length) {
        this.length = length;
    }

    public double getlength() {
        return length;
    }

    public double getArea() {
        double Rectanglearea = getwidth() * getlength();
        return Rectanglearea;
    }
    
}
class Triangle extends shape
{
    public Triangle(double a,double b,double c)
    {
        this.a=a;
        this.b=b;
        this.c=c;
    }
    private double a;
    private double b;
    private double c;
    public void seta(double a) {
        this.a = a;
    }

    public double geta() {
        return a;
    }
    public void setb(double b) {
        this.b = b;
    }

    public double getb() {
        return b;
    }
    public void setc(double c) {
        this.c = c;
    }

    public double getc() {
        return c;
    }
    
    public double getArea() {
        double p=(a+b+c)/2.0;
        double Trianglearea=Math.sqrt(p*(p-a)*(p-b)*(p-c));
        return Trianglearea;
    }
    public boolean check()
    {
        if((a+b>c&&a+c>b&&b+c>a)&&(Math.abs(a-b)<c&&Math.abs(a-c)<b&&Math.abs(b-c)<a))
        return true;
        else
        return false;
    }

}
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int Circlenum=in.nextInt();
        int Rectanglenum=in.nextInt();
        int Trianglenum=in.nextInt();
        
        int flag=0;
        double  []Circlearea = new double[1000];
        double  []Rectanglearea = new double[1000];
        double  []Trianglearea = new double[1000];
        if(Circlenum<0||Rectanglenum<0||Trianglenum<0)
        {
            System.out.println("Wrong Format");
        }
        else
        {
        for(int i=0;i<Circlenum;i++)                       //圆
        {
            double r=in.nextDouble();
            if(r<=0)
            {
                System.out.println("Wrong Format");
                flag=1;
                break;
            }
            else
            {
            Circle circle = new Circle(r);
            Circlearea[i]=circle.getArea();
            }
        }
        if(flag==0)
        {
        for(int i=0;i<Rectanglenum;i++)             //矩形
        {
            double width=in.nextDouble();
            double length=in.nextDouble();
            if(width<0||length<0)
            {
                System.out.println("Wrong Format");
                flag=1;
                break;
            }
            else
            {
                Rectangle rectangle = new Rectangle(width,length);
                Rectanglearea[i]=rectangle.getArea();
            }
        }
        }
        if(flag==0)
        {
            for(int i=0;i<Trianglenum;i++)                        //三角形
            {
                double a=in.nextDouble();
                double b=in.nextDouble();
                double c=in.nextDouble();
                if(a<0||b<0||c<0)
                {
                    System.out.println("Wrong Format");
                    flag=1;
                    break;
                }
                else
                {
                    Triangle triangle = new Triangle(a,b,c);
                    if(triangle.check())
                    {
                    Trianglearea[i]=triangle.getArea();
                    }
                    else
                    {
                    flag=1;
                    System.out.println("Wrong Format");
                    break;
                    }
                }
            }
        }
        }
        if(flag==0)
        {
        DecimalFormat df = new DecimalFormat("0.00");
        double []shape = new double[Circlenum+Rectanglenum+Trianglenum]; 
        double num1=0,num2=0,num3=0;
        System.out.println("Original area:");
        if(Circlenum==0&&Rectanglenum==0&&Trianglenum==0)
        {
            System.out.println("");
        }
        for(int i=0;i<Circlenum;i++)
        {
            shape[i]=Circlearea[i];
            System.out.print(df.format(Circlearea[i])+" ");
            num1=num1+Circlearea[i];
        }
        for(int i=0;i<Rectanglenum;i++)
        {
            shape[i+Circlenum]=Rectanglearea[i];
            if(Trianglenum==0&&i==Rectanglenum-1)
            System.out.println(df.format(Rectanglearea[i])+" ");
            else
            {
                System.out.print(df.format(Rectanglearea[i])+" ");
            }
            num2=num2+Rectanglearea[i];
        }
        for(int i=0;i<Trianglenum;i++)
        {
            shape[i+Rectanglenum+Circlenum]=Trianglearea[i];
            if(i==Trianglenum-1)
            System.out.println(df.format(Trianglearea[i])+" ");
            else
            {
            System.out.print(df.format(Trianglearea[i])+" ");    
            }
            num3=num3+Trianglearea[i];
        }
        System.out.println("Sum of area:"+df.format((num1+num2+num3)));
        System.out.println("Sorted area:");
        if(Circlenum==0&&Rectanglenum==0&&Trianglenum==0)
        {
            System.out.println("");
        }
        for(int i=0;i<shape.length-1;i++)
        {
            for(int j=0;j<shape.length-1-i;j++)
            {
                if(shape[j]>shape[j+1])
                {
                double t=shape[j];
                shape[j]=shape[j+1];
                shape[j+1]=t;
                }
            }
        }
        for(int i=0;i<shape.length;i++)
        {
            if(i==shape.length-1)
            System.out.println(df.format(shape[i])+" ");
            else
            System.out.print(df.format(shape[i])+" ");
        }
        System.out.println("Sum of area:"+df.format((num1+num2+num3)));
        
    }
    }
}

 

3.题目集6（7-6）实现图形接口及多态性 ：

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

其中：

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

输入格式:

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

输出格式:

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

测试结果：

 

 

 

 

        分析：此题运用了接口，首先我们需要了解接口是什么？

                  接口：（点击此处了解更多）

                           Java接口是一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为（功能）。

                  基本了解接口后，在根据类图所提供的思路，此题并不难，其大致的思路与前面两题相同，只是使用的技术不同

             

import java.text.DecimalFormat;
import java.util.Scanner;

interface GetArea
{
     double getArea();
}
class Circle implements GetArea
{
    private double radius;
    public void setRadius(double radius)
    {
        this.radius=radius;
    }

    public double getRadius() {
        return radius;
    }
    public Circle(double radius)
    {
        this.radius=radius;
    }
    public Circle(){}

    @Override
    public double getArea() {
        return Math.PI*radius*radius;
    }
}

class Rectangle implements GetArea
{
    private double width;
    private double length;

    public void setWidth(double width) {
        this.width = width;
    }

    public double getWidth() {
        return width;
    }

    public void setLength(double length) {
        this.length = length;
    }

    public double getLength() {
        return length;
    }

    public Rectangle(double width,double length)
    {
        this.length=length;
        this.width=width;
    }
    public Rectangle(){}

    @Override
    public double getArea() {
        return width*length;
    }
}
public class Main {
    public static void main(String[] args) {
            Scanner in = new Scanner(System.in);
            double radius=in.nextDouble();
            double width=in.nextDouble();
            double length=in.nextDouble();
            Circle circle = new Circle(radius);
            Rectangle rectangle= new Rectangle(width,length);
            DecimalFormat df = new DecimalFormat("0.00");
            if(radius<=0||width<=0||length<=0)
            {
                System.out.println("Wrong Format");
            }
            else {
                System.out.println(df.format(circle.getArea()));
                System.out.println(df.format(rectangle.getArea()));
                }
            
            
    }
}

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

 常用语法参考：

• . - 除换行符以外的所有字符。
• ^ - 字符串开头。
• $ - 字符串结尾。
• \d,\w,\s - 匹配数字、字符、空格。
• \D,\W,\S - 匹配非数字、非字符、非空格。
• [abc] - 匹配 a、b 或 c 中的一个字母。
• [a-z] - 匹配 a 到 z 中的一个字母。
• [^abc] - 匹配除了 a、b 或 c 中的其他字母。
• aa|bb - 匹配 aa 或 bb。
• ? - 0 次或 1 次匹配。
• * - 匹配 0 次或多次。
• + - 匹配 1 次或多次。
• {n} - 匹配 n次。
• {n,} - 匹配 n次以上。
• {m,n} - 最少 m 次，最多 n 次匹配。
• (expr) - 捕获 expr 子模式,以 \1 使用它。
• (?:expr) - 忽略捕获的子模式。
• (?=expr) - 正向预查模式 expr。
• (?!expr) - 负向预查模式 expr。

1.String.matches() :matches()是全部匹配，是将整个输入串与模式匹配，如果要验证一个输入的数据是否为数字类型或其他类型，一般要用matches()。如果匹配则为true,否则为false;

2.String.find:  find()方法是部分匹配，是查找输入串中与模式匹配的子串，如果该匹配的串有组还可以使用group()函数。如果匹配则为true,否则为false;

3.当使用matches(),lookingAt(),find()执行匹配操作后,就可以利用以上三个方法得到更详细的信息. 

start()返回匹配到的子字符串在字符串中的索引位置. 
end()返回匹配到的子字符串的最后一个字符在字符串中的索引位置. 
group()返回匹配到的子字符串 

④题目集5（7-4）统计Java程序中关键词的出现次数 中Java集合框架应用的分析总结：

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

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

输入格式:

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

输出格式:

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

 

测试结果：

 

 

分析：

            此题会运用集合中的List、Set或Map一种或多种(点击这里了解更多）

          在这里我使用了Map(Map中的集合，元素是成对存在的(理解为夫妻)。每个元素由键与值两部分组成，通过键可以找对所对应的值。)

           首先是53个关键字："abstract", "boolean", "break", "byte", "case",

 

   "catch", "char", "class", "continue", "default", "do", "double",

 

   "else", "extends", "false", "final", "finally", "float", "for",

 

   "if", "implements", "import", "instanceof", "int", "interface",

 

   "long", "native", "new", "null", "package", "private", "protected",

 

   "public", "return", "short", "static", "super", "switch",

 

   "synchronized", "this", "throw", "throws", "transient", "true",

 

   "try", "void", "volatile", "while", "const", "goto","enum","assert" ,"strictfp"

      其次考虑到是输入代码，而代码较多且长，所以在这里我使用Stringbuffer（动态字符串数组）并使用append()往动态字符串数组添加（跟“xxxx”+“yyyy”相当那个‘+’号 ）之后所有的代码都存在了一个字符串数组里。

      之后再使用正则表达式（find)进行匹配，若匹配到关键字则t++，匹配完后把t作为键值（map.put(keywords[i], t)）存入集合中

      PS：1.关键字中有部分相同的情况，如：do和double，throw和throws所以在进行正则表达式的书写时要在两边加上\b（String pattern = "\\b"+keywords[i]+"\\b"），否则在匹配是double中的do也会被当做do进行匹配。

               2.由于注释中也会可能出现关键字，但注释中出现的关键字并不能算，所以采用String a = all.toString().replaceAll("/\\*\\s*.*\\s*\\*/", "")来清楚注释段的代码

 

import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Scanner;
import java.util.TreeMap;
import java.util.regex.Matcher;
import java.util.regex.Pattern;



public class Main {
    
    public static void main(String args[]) {
        Scanner in = new Scanner(System.in);
        Map map=new TreeMap();
        String[] keywords = { "abstract", "boolean", "break", "byte", "case",

                   "catch", "char", "class", "continue", "default", "do", "double",

                   "else", "extends", "false", "final", "finally", "float", "for",

                   "if", "implements", "import", "instanceof", "int", "interface",

                   "long", "native", "new", "null", "package", "private", "protected",

                   "public", "return", "short", "static", "super", "switch",

                   "synchronized", "this", "throw", "throws", "transient", "true",

                   "try", "void", "volatile", "while", "const", "goto","enum","assert" ,"strictfp"};
        
        String abc="";
        StringBuilder all = new StringBuilder();
        int flag=0;
        while( !(abc = in.nextLine()).equals("exit"))
        {
            flag=1;
            all.append(abc.replaceAll("//.*", "").replaceAll("\".*\"", ""));
        }
        String a = all.toString().replaceAll("/\\*\\s*.*\\s*\\*/", "");
        if(flag!=1)
        {
            System.out.println("Wrong Format");
        }
        //System.out.print(all);
        
        for(int i=0;i<53;i++) {
            String pattern = "\\b"+keywords[i]+"\\b";
            Pattern r = Pattern.compile(pattern);
            Matcher m = r.matcher(a);
            int t=0;
            while(m.find())
            {
              t++;
              //System.out.println(m.group());
            }
            if(t!=0)
            map.put(keywords[i], t);
        }
        
        sortMap(map);
        //System.out.print("ok");
    }
     static void sortMap(Map<String, String> param) {
            TreeMap<String, String> paramTreeMap = new TreeMap<>(param);
            Iterator iterator = paramTreeMap.entrySet().iterator();
            while (iterator.hasNext()) {
                String a = iterator.next().toString();
                System.out.println(a.split("=")[1] + "\t" + a.split("=")[0]);
            }
        }
}

 

 

 

三.总结：          

      在这几次的题目中我熟练运用了正则表达式和封装，并基本掌握了继承，多态以及接口的相关知识。但是对于多态和接口的运用相对来说不够熟练，还需要进一步加强练习

     关于教学上的意见，我觉得老师的教学很好，课堂也很精彩生动。线上作业方面，题目对我们的知识利用也有很好的帮助，并且我觉得进行实践方面的操作更能增加我们对知识的运用，增加我们的熟练度，所以我觉得每周一次的大作业和实验很有帮助，但我的个人感受就是，有些时候题目做的比较快的话，做完后就找不到题做了，想要练手但是又缺乏题目，没有题目做载体，自己也不知道从何开始，所以老师能不能整理一个单独的题目集供我们练手（自愿学习，没有时间限制的那种），不是说作业太少就是，只是想要在自己自主学习的时候有一个比较好的载体进行学习。

     除此以外，在发布pta作业，能否把每个测试点想要表面的意图有个清楚明了的阐述，每次在做题的有测试点过不去时，有些测试点并不知道其重点在哪，自己也不太清楚自己的代码有哪些漏洞，自己也难以猜测那个测试点的点在哪。