OO题目集4~6总结

一、前言

　　在这三次的题目集中，主要考查的有对数据的处理，Java中对聚合和组合的使用，以及Java中的封装、继承和多态的运用。在这些基础的Java编程当中，还适当地考到了正则表达式的使用以及抽象类和接口的运用，其中继承的相关练习比较多，有利于我们对于Java继承更加地熟练；对于题量的分布也还合理，其中题目集4有3道题目，题目集5有5道题目，题目集6也有5道题目；题型的难度有易有难，在每一次的题目集中都有简单的题和困难的题，而且难度的划分也较为明显，有利于我们对于题目的的简单难易的分析；分布也还行，在每一次的题目集当中，都会有比较全面知识考点，有简单也有难的考点，考查了我们对于编程较为广泛的考查，同时也没有特别难的题来对同学们打压学习Java编程的信心。

二、设计与分析

（一）题目集4（7-2）设计与分析：

　　题目集4（7-2）是日期问题面向对象设计（聚合一），首先根据题目的意思将设计该程序的大致类图的框架用代码实现，然后再根据题目所给的要求和提示将题目中要求的一个一个类进行实现，实现其功能以及相关的判断。按照题目的要求，首先定义了5个类，Main类、Year类、Month类、Day类和DateUtil类，其中Year类实现了判断输入的年份是否合法并且在输入数据合法的情况下判断是否为闰年，并且还有年份增1和减1的方法；在Month类里面也有判断输入的月份是否合法的判断，也有月份增1和减1的方法，与此同时还添加了月份复位和月份设置为12的方法，将程序运行过程月份会发生改变的地方全部都有进行实现；而在Day类里面和Month类的功能基本一致，判断输入数据的合法性，日期增1和减1，日期复位和日期改为月最大值，在这时就需要判断的东西比较多，例如每个月的最后一天会不一样，即月最大值也就不一样，此时我使用一个数组来实现这一变化，当然，是不是闰年还将会改变2月份的月最大值，所以我还需要判断该年是不是闰年，这样才难使我的程序更加完整；而DateUtil类则主要是对日期进行计算和校验，在这个过程中就需要有Year类、Month类和Day类的聚合关系共同来完成，其中包含有检验输入数据的合法性，比较2个日期的大小、判断两个日期是否相等、日期值格式化、求下n天、求前n天以及求2个日期之间的天数。以上4个类就是实现该程序的主要方法。我的判断日期代码是否合法采用的是一层接一层的方式：判断年数据是否合法：

public boolean validate(){
        boolean validate =(value>=1900&&value<=2050);
        return validate;
    }

判断月数据是否合法：

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

判断日期是否合法：

public boolean validate(){
        if(month.getYear().validate()&&month.validate()){
            if(month.getValue()==2&&month.getYear().isLeapYear()){
                if(this.value>=1&&this.value<=29) return true;
                else return false;
            }
            else if(month.getValue()==2&&!month.getYear().isLeapYear()){
                if(this.value>=1&&this.value<=28) return true;
                else return false;
            }
            else if(month.getValue()==1||month.getValue()==3||month.getValue()==5||month.getValue()==7||month.getValue()==8||month.getValue()==10||month.getValue()==12){
                if(this.value>=1&&this.value<=31) return true;
                else return false;
            }
            else if(month.getValue()==4||month.getValue()==6||month.getValue()==9||month.getValue()==11){
                if(this.value>=1&&this.value<=30) return true;
                else return false;
            }
            else return false;    
        }
        else return false;
    }

DateUtil类判断数据合法则只需判断日期即可：

public boolean checkInputValidity(){
        if(day.validate()) return true;
        else return false;
    }

（二）题目集4（7-3）设计与分析：

　　题目集4（7-3）是对于图形的继承，首先读懂题目意思，并且按照题目的意思定义好5个类。类Shape，无属性，有一个返回0.0的求图形面积的公有方法；类Circle，继承自Shape，有一个私有实型的属性radius（半径），重写父类继承来的求面积方法，求圆的面积；类Rectangle，继承自Shape，有两个私有实型属性width和length，重写父类继承来的求面积方法，求矩形的面积；类Ball，继承自Circle，其属性从父类继承，重写父类求面积方法，求球表面积，此外，定义一求球体积的方法；类Box，继承自Rectangle，除从父类继承的属性外，再定义一个属性height，重写父类继承来的求面积方法，求立方体表面积，此外，定义一求立方体体积的方法。并且所求的一系列的面积和体积最后都要保留2位小数，同时，如果输入的数据有误，要输出Wrong Format，同时结束程序；而这些输入的实现以及判断是求什么物体的判断都是放在主类里面进行，判断输入数据的合法性也由主类来进行判断和实现，题目中主类要求实现的是：主方法内，主要实现四个功能（1-4）： 从键盘输入1，则定义圆类，从键盘输入圆的半径后，主要输出圆的面积； 从键盘输入2，则定义矩形类，从键盘输入矩形的宽和长后，主要输出矩形的面积； 从键盘输入3，则定义球类，从键盘输入球的半径后，主要输出球的表面积和体积； 从键盘输入4，则定义立方体类，从键盘输入立方体的宽、长和高度后，主要输出立方体的表面积和体积；假如数据输入非法（包括圆、矩形、球及立方体对象的属性不大于0和输入选择值非1-4），系统输出Wrong Format。注意求圆的面积或者是球的表面积和体积时，Π不能直接取3.14，而应该取Math.PI，就如我的求球的表面积和体积继承圆的代码一样，如下：

class Ball extends Circle{
    Ball(){
        System.out.println("Constructing Ball");
    }
    public double getArea(){
        double r = getradius();
        return 4*Math.PI*Math.pow(r, 2);
    }
    public double getVolume(){
        double r = getradius();
        return (4.0/3.0)*Math.PI*Math.pow(r, 3);        
    }
}

我的主类代码判断数据的合法采用的是运用if，else进行判断，主类代码如下：

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        // TODO 自动生成的方法存根
        Scanner input = new Scanner(System.in);
        int n = input.nextInt();
        if(n==1){
            double r = input.nextDouble();
            if(r<0)
                System.out.println("Wrong Format");
            else{
                Circle circle = new Circle();
                circle.setradius(r);
                System.out.printf("Circle's area:%.2f",circle.getArea());
            }
        }
        else if(n==2){
            double w =input.nextDouble();
            double l =input.nextDouble();
            if(w<0||l<0)
                System.out.println("Wrong Format");
            else {
                Rectangle rectangle =new Rectangle();
                rectangle.setlebgth(l);
                rectangle.setwidth(w);
                System.out.printf("Rectangle's area:%.2f",rectangle.getArea());
            }
        }
        else if(n==3){
            double r= input.nextDouble();
            if(r<0)
                System.out.println("Wrong Format");
            else{
                Ball ball = new Ball();
                ball.setradius(r);
                System.out.printf("Ball's surface area:%.2f",ball.getArea());
                System.out.printf("\nBall's volume:%.2f",ball.getVolume());
            }
        }
        else if(n==4){
            double w =input.nextDouble();
            double l =input.nextDouble();
            double h =input.nextDouble();
            if(w<0||l<0||h<0)
                System.out.println("Wrong Format");
            else{
                Box box = new Box();
                box.setwidth(w);
                box.setlebgth(l);
                box.setheight(h);
                System.out.printf("Box's surface area:%.2f", box.getArea());
                System.out.printf("\nBox's volume:%.2f",box.getVolume());
            }
        }
        else
            System.out.println("Wrong Format");
    }
}

（三）题目集5（7-4）设计与分析：

 　　题目集5（7-4）是统计Java程序中关键词的出现次数；首先我去查找了Java语言中的53个关键字，首先是将一段源代码输入进去，然后再用正则表达式将注释的内容删去，这样可以首先将注释掉的内容里面可能会有关键字的情况排除在外了，就不用后面再去判断取出的关键字是不是注释里面的了，再者就是将代码中有空格的或者是有符号的地方作为分界点，并且将分好的每一小段代码存放在数组中，然后再从这一堆的数组中查找在程序开头定义好的53个关键字，并且将统计好的所有关键字按照开始程序定义好的53个Java关键字一样的顺序排出。并且检验源码是否结束的操作则是：以exit行作为结束标志，判断源码是否已经结束，并且当当未输入源码时，程序输出Wrong Format；当没有统计数据时，输出为空；当有统计数据时，关键字按照升序排列，每行输出一个关键字及数量。这题采用正则表达式是一种较为快捷和正确的编写方式，下面是Java中的53个关键字（已经排好序的）：

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"
        };

（四）题目集5（7-5）设计与分析：

　　题目集5（7-5）是日期问题面向对象设计（聚合二），该题和题目集4（7-2）的要求是一样的，但是数据有略微的改动，将年份的区间从[1900,2050]改成[1820,2020]，这点细小的差别是要好好注意的，不然可能会浪费自己很多的时间在寻找程序的错误而难以发现自己原来只是因为题目中的一个小细节没有发现而感到很不应该，这也是大家最不想犯的低级错误，所以应该好好看清题目；再者该题的聚合类型和题目集4（7-2）的有所不同，题目集4（7-2）是4个类之间层层聚合，而这道题目的聚合则是有DateUtil类向其他的3个类发散聚合，这就是于题目集4（7-2）的不同之处。而我便是在题目集4（7-2）代码的基础上进行略微的修改，从而实现这道题程序代码的实现。我的判断数据是否合法的代码已经在上面题目集4（7-2）的设计与分析中进行展示，在这我将展示增1和减1的相关代码，年份增1和减1：

public void yearIncrement(){
        this.value++;
    }
public void yearReduction(){
        this.value--;
    }

月份增1和减1：

public void monthIncrement(){
        if(this.value==12){
            year.yearIncrement();
            this.value=1;
        }
        else this.value++;
    }
public void monthReduction(){
        if(this.value==1){
            year.yearReduction();
            this.value=12;
        }
        else this.value--;    
    }

日期增1和减1：

public void dayIncrement(){
        if(month.getYear().isLeapYear()){
            if(this.value==29&&month.getValue()==2){
                month.monthIncrement();
                this.value=1;
            }
            else if(this.value==30&&(month.getValue()==4||month.getValue()==6||month.getValue()==9||month.getValue()==11)){
                month.monthIncrement();
                this.value=1;
            }
            else if(this.value==31&&(month.getValue()==1||month.getValue()==3||month.getValue()==5||month.getValue()==7||month.getValue()==8||month.getValue()==10||month.getValue()==12)){
                month.monthIncrement();
                this.value=1;
            }
            else this.value++;
        }
        else if(!month.getYear().isLeapYear()){
            if(this.value==28&&month.getValue()==2){
                month.monthIncrement();
                this.value=1;
            }
            else if(this.value==30&&(month.getValue()==4||month.getValue()==6||month.getValue()==9||month.getValue()==11)){
                month.monthIncrement();
                this.value=1;
            }
            else if(this.value==31&&(month.getValue()==1||month.getValue()==3||month.getValue()==5||month.getValue()==7||month.getValue()==8||month.getValue()==10||month.getValue()==12)){
                month.monthIncrement();
                this.value=1;
            }
            else this.value++;
        }
    }
public void dayReduction(){
        if(month.getYear().isLeapYear()){
            if(this.value==1&&month.getValue()==3){
                month.monthReduction();
                this.value=29;
            }
            else if(this.value==1&&(month.getValue()==5||month.getValue()==7||month.getValue()==10||month.getValue()==12)){
                month.monthReduction();
                this.value=30;
            }
            else if(this.value==1&&(month.getValue()==1||month.getValue()==2||month.getValue()==4||month.getValue()==6||month.getValue()==8||month.getValue()==9||month.getValue()==11)){
                month.monthReduction();
                this.value=31;
            }
            else this.value--;
        }
        else if(!month.getYear().isLeapYear()){
            if(this.value==1&&month.getValue()==3){
                month.monthReduction();
                this.value=28;
            }
            else if(this.value==1&&(month.getValue()==5||month.getValue()==7||month.getValue()==10||month.getValue()==12)){
                month.monthReduction();
                this.value=30;
            }
            else if(this.value==1&&(month.getValue()==1||month.getValue()==2||month.getValue()==4||month.getValue()==6||month.getValue()==8||month.getValue()==9||month.getValue()==11)){
                month.monthReduction();
                this.value=31;
            }
            else this.value--;
        }
    }

（五）题目集6（7-5）设计与分析：

　　题目集6（7-5）是图形继承与多态，看完作业指导书，首先定义了应该抽象的父类Shape，然后下面再定义Circle类、Rectangle类和Triangle类，全部作为子类继承父类Shape；在父类Shape中包含求面积和判断输入数据是否正确这2个抽象方法；子类对这2个方法进行继承和多态，进一步对圆，矩形和三角形的面积进行求解；但是主类一开始不是很好写，因为题目要求是：从键盘首先输入三个整型值（例如a b c），分别代表想要创建的Circle、Rectangle及Triangle对象的数量，然后根据图形数量继续输入各对象的属性值（均为实型数），数与数之间可以用一个或多个空格或回车分隔。也就是说可能一种图形为0个，而另一种图形可能就会有很多个，一开始的我无从下手，后面我决定采用for循环的方式进行求解，果真实现了，于此同时对于面积的排序我采用的是数组进行排序，将其存在一个数组中，再对这个数组中的元素进行排序，从而实现对面积大小的排序，最后要注意输出的结果最后都要保留2位小数，下面是我的主类的代码：

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        // TODO 自动生成的方法存根
        Scanner input = new Scanner(System.in);
        int a = input.nextInt();
        int b = input.nextInt();
        int c = input.nextInt();
        double sum = 0; 
        double [] S = new double [100]; 
        if(a<0||b<0||c<0)
            System.out.println("Wrong Format");
        else{
            for(int i=1;i<=a;i++) {            //圆
                double radius = input.nextDouble();
                Circle circle = new Circle(radius);
                if(!circle.validate()) {
                    System.out.println("Wrong Format");
                    System.exit(0);
                }
                else {
                    S[i-1] = circle.getArea();
                }
            }
            for(int j=1;j<=b;j++) {            //矩形
                double width = input.nextDouble();
                double length = input.nextDouble();
                Rectangle rectangle = new Rectangle(width,length);
                if(!rectangle.validate()) {
                    System.out.println("Wrong Format");
                    System.exit(0);
                }
                else {
                    S[a-1+j] = rectangle.getArea();
                }
            }
            for(int k=1;k<=c;k++) {            //三角形
                double side1 = input.nextDouble();
                double side2 = input.nextDouble();
                double side3 = input.nextDouble();
                Triangle triangle = new Triangle(side1,side2,side3);
                if(!triangle.validate()) {
                    System.out.println("Wrong Format");
                    System.exit(0);
                }
                else {
                    S[a+b-1+k] = triangle.getArea();
                }
            }
            System.out.println("Original area:");
            for(int i = 0;i<(a+b+c);i++) {
                System.out.printf("%.2f ",S[i]);
            }
            for(int i= 0;i<(a+b+c);i++) {
                sum = sum +S[i];
            }
            System.out.printf("\nSum of area:%.2f\n",sum);
            for(int i=0;i<(a+b+c);i++) {
                for(int k=i;k>0;k--) {
                    if(S[k]<S[k-1]) {
                        double temp = S[k-1];
                        S[k-1] = S[k];
                        S[k] = temp;
                    }
                }
            }
            System.out.println("Sorted area:");
            for(int i = 0;i<(a+b+c);i++) {
                System.out.printf("%.2f ",S[i]);
            }
            System.out.printf("\nSum of area:%.2f\n",sum);

        }
    }
}

（六）题目集6（7-6）设计与分析：

　　题目集6（7-6）是实现图形接口及多态性；首先按照题目将题目中的GetArea接口，接口中只有一个抽象的GetArea方法，接下来按照题目意思定义两个类：Circle类和Rectangle类，用于实现GetArea接口；再根据题目中的类图，将题目中的Circle类和Rectangle类中的属性和方法写全；最后写主类，在主方法中分别定义一个圆类对象及矩形类对象（其属性值由键盘输入），使用接口的引用分别调用圆类对象及矩形类对象的求面积的方法，直接输出两个图形的面积值。只但是仍然需要注意输出的面积结果保留两位小数，如果3个输入数据有一个有误，将输出：Wrong Format。判断数据输入错误：

if(radius<=0||width<=0||length<=0) {
            System.out.print("Wrong Format");
        }

GetArea接口：

interface GetArea{
    public abstract double getArea();
}

Circle类：

class Circle implements GetArea{
    private double radius;
    public double getRadius() {
        return radius;
    }
    public void setRadius(double radius) {
        this.radius = radius;
    }
    public Circle(double radius){
        this.radius = radius;
    }
    public Circle(){
        
    }
    public double getArea() {
        return Math.PI*Math.pow(radius, 2); 
    }
}

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

·题目集4（7-2）相关图

   

·题目集5（7-5）相关图

　　题目集4（7-2）的日期类聚合设计是一个一个类依次嵌套聚合，运用这样的方式书写程序可以使程序在书写过程中可以依次紧密相结合，可以做到紧凑；同时在编写代码的过程中可以让自己的编写思路紧紧跟着年月日这样的方式去书写，可以让我们编写出来的代码更加有条理，更加清晰。题目集5（7-5）的日期类聚合设计则是由一个中间类DateUtil类去找年月日这3个类聚合，展现出一种发散的样式的聚合类的情况，采用这样的方式去书写代码则可以大大减少运行程序的时间复杂度，可以使得程序更加高效地计算出相关日期的求解结果。

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

·题目集4（7-3）相关图

·题目集6（7-5）相关图

·题目集6（7-6）相关图

　　在这3道题目中共同拥有的是封装、继承和多态，都是采用private的属性对其相关的属性进行编写；题目集4（7-3）是较为简单的图形继承，就是简单的继承Shape类，使其为一个父类，而Circle类和Rectangle类则继承Shape类，作为其子类，与此同时，Circle类和Rectangle类也分别作为Ball类和Box的父类，使得Ball类和Box继承Circle类和Rectangle类的相关内容，当然，对于getArea的方法采用了多态的方法进行书写，大大提高了代码的可复用性，使得程序更加灵活；题目集6（7-5）是比较难的图形继承题，主要是难在它所要求的3种图形的数量不只是当当的1，而是可以选择数量的图形，而在继承方面，首先定义了一个抽象的Shape类，其中有2个抽象的方法：getArea和validate；Circle类、Rectangle类和Triangle类都是继承Shape类，作为其子类，getArea方法和validate方法都采用多态对其进行书写，使得程序的可复用性大大提升，同时在主类中采用for循环对于不同类型的图形的数量进行new对象，做到对图形数量的精确控制，实现程序的功能；题目集6（7-6）的图形继承采用了接口，定义了一个GetArea的接口，里面含有一个抽象的getArea方法，而Circle类和Rectangle类都是承接GetArea接口，然后再到Circle类和Rectangle类里面进行面积的求解，这题主要是采用了接口来编写程序，其实并不是特别难。

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

　　这三次的正则表达式技术主要是集中在题目集6，在题目集6中需要运用正则表达式的题目高达3题，有检验QQ号、检验验证码和检验学号这3道题目，都是较为简单的正则表达式的运用，主要是使用了matches的方法对于输入的数据进行正则判断，检验输入的数据是否符合题目的要求，正则表达式还是较为简单掌握的，在这3道题目中我认为较为难一点的题目就是学号的检验吧，因为需要考虑的东西会比QQ号的检验和验证码的检验难一点，所以在此我展示我所写的学号检验的代码：

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        // TODO 自动生成的方法存根
        String regex = "2020(11||12||13||14||15||16||17||61||71||72||73||81||82)([0][1-9]||[123][0-9]||40)";
        Scanner input = new Scanner(System.in);
        String s = input.nextLine();
        input.close();
        if(s.matches(regex)) {
            System.out.print("正确");
        }
        else {
            System.out.print("错误");
        }
    }
}

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

·题目集5（7-4）相关图

 

　　在解决这道题目时我的思路是没有特别地清晰，导致后面我在提交结束之前并没有将这道题目解出来，但是后面在题目结束之后，我和同学们一起探讨这道题目的解法后我得到了一个大家都认为较为正确得解题方法，运用了Pattern和Matcher以及find和group得方法来对源代码进行相应的求解和储存，还使用了ArrayList对选中的Java关键字进行搜集和排序，还使用了replace的方法对代码中的相关符号进行替代，最后找出那53个Java关键字，还使用了字符串的相关方法对搜集到的每一个元素进行相应的整理，最后输出。

三、踩坑心得

 　　在题目集4（7-2）和题目集5（7-5）这2道题目中，同样都是日期类的聚合，千万不要盲目地看到题目大致一样就草率地修改一下程序，在题目中可能会有十分细小的地方需要我们去好好注意，在这2道题目中我没有较为认真地看第二道题目，导致我的第二道题有一个点一直过不了，最后发现这个点竟然是2道题的年份区间改了，不一样了，而我仍然采用的是上一道题的年份空间，导致我花了大量的时间在寻找程序的错误，最后才发现竟然只是一个小小的年份错误，所以在以后一定要好好看请楚题目，再动手写代码；

public boolean validate(){
        boolean validate =(value>=1900&&value<=2050);
        return validate;
    }

public boolean validate(){
        boolean validate =(value>=1820&&value<=2020);
        return validate;
    }

　　再者就是正则表达式的运用要十分注意\和/的区别和运用，并且一定要好好学好正则表达式，正则表达式再今后的学习和解题方面会有很大的帮助，并且学好了正则表达式也会十分便捷，可以大大减少我们判断数据的过程；

String regex = "[1-9][0-9]{4,14}";

String regex = "[0-9a-zA-Z]{4}";

String regex = "2020(11||12||13||14||15||16||17||61||71||72||73||81||82)([0][1-9]||[123][0-9]||40)";

　　而在题目集4（7-3）、题目集6（7-5）和题目集6（7-6）中的图形继承问题中，一定要判断清楚哪个类作为父类，哪个作为子类，一个子类只能有一个父类，而一个父类可以有多个子类，不能违反了这个规则，与此同时对于private类型的数据一定要记得写上setter和getter方法，这样可以保证程序的完整性，让程序完好。

private double radius;
    public double getRadius() {
        return radius;
    }
    public void setRadius(double radius) {
        this.radius = radius;
    }

　　 总而言之，对于编写代码这方面，还是需要多写、多练，不能怠慢，自己要要善于在错误中寻找到正确的编写代码的过程，并且总结自己发生错误的情况，在以后编写程序的时候要特别关注这方面可能会发生的错误，要尽量去避免，不能每写一次代码都犯，这样的学习方式是无效的，要在学习过程中做到高效，不能随意敷衍，需要认真对待自己的每一道题，要有所收获。

四、改进建议

 　　首先，对于含有正则表达式出现的程序，我认为可以在原有的判断之中加入其他的一些情况的发生，比如像数字和字母的结合，以及和一些特殊符号的相结合，这些多种情况的相结合，可以适当地提高程序的难度，同时也可以在编写正则表达式的过程中锻炼到我们的逻辑思维能力，同时也可以让我们更加深入了解到正则表达式的书写和格式；其次，在图形的继承的相关题目中，我认为继承的东西可以有多一点，并且我认为也可以试着多去写一些接口一类的代码，可以让我们多加了解一些关于Java的语句和语法的写法以及区别，这样的编写可以提升我们对于Java编程的更进一步的熟悉；再者，对于日期聚合类的设计的代码，可以尝试着用继承和多态的方法去书写，就好比判断数据是否输入非法的方法，可以尝试去运用继承看看能不能编写出来，毕竟是要多加创新，不能一昧地只是采用聚合的方法去书写代码，可以换个思路去思考；最后，对于有关排序相关的程序，可以试着使用不一样的方法去排序，例如：利用ArrayList去排序，sort排序以及compare to去解决相关的问题，总结下来就是：每个题目都有自己的见解，同时也可以采用多种不一样的方法进行解题，解决问题的方法并不唯一，可以多加探索。

五、总结

 　　在这3次的题目集中，涉及的知识点比较多，语句、语法也比较多，但是这样的作业也可以很好地让我们掌握相关的知识点，像在这3次的题目集中，让我们学到了聚合的写法和继承、封装、多态以及正则表达式的相关内容，对于聚合，我认为也是Java中一种比较重要的东西，聚合的类之间是就是可以之间单独存在，不会有依赖的关系，但是继承就必须要有依赖的关系，有子类和父类的关系，继承指的是一个类（称为子类、子接口）继承另外的一个类（称为父类、父接口）的功能，并可以增加它自己的新功能的能力，继承是类与类或者接口与接口之间最常见的关系，而聚合则是聚合是关联关系的一种特例，他体现的是整体与部分、拥有的关系，即has-a的关系，此时整体与部分之间是可分离的，他们可以具有各自的生命周期，部分可以属于多个整体对象，也可以为多个整体对象共享；这就是二者的区别，于此同时，经过这3次的题目集的学习，我对于正则表达式的运用也更加熟练，对于一些简单的数据判断可以十分快速地写出其正则表达式进行判断，同样的，排序在Java中也有相应的方法来进行排序，同样也可以重新书写方法来对排序的东西以及排序的过程进行修改，可以说是特别便捷。基础的编程相关知识也都还有，数学函数的运用和输出保留2位小数类似的小问题，这些也不容忽视，要多加练习，努力让自己对这些基础的东西烂熟于心，绝不允许出现这样的低级错误。通过这3次的题目集作业，我主要对于Java聚合，类设计以及正则表达式有了很大的收获，在这几个方面，我对Java编程有了更熟悉的了解，也对Java编程有了一定的信心去学好这门语言。

　　总的来说，这3次的题目集让我学到了不少的东西，同时也让我对Java语言的学习有了一定的信心，要相信自己一定可以学好这门语言，并且一直保持下去。