OO前三次作业总结

1、前言（对前三次作业的总结）

　　前三次作业分别考察了：1.对java基本结构的运用以及数组的运用。2.对类中方法的理解与调用。3.对私有属性的修改与提取以及对复杂方法的思考。

　　题量：逐级递增，对时间的规划要求不断的提高。

　　难度：逐级递增，作业三7-3未能在规定时间内达到理想状态。（实在是菜的真实

2、设计与分析

　　题目集一：7-8

import java.util.Scanner;
import java.util.Arrays;
public class Main
{
    public static void main(String[] args)
    {
        int i;
        Scanner input = new Scanner(System.in);
        double[] a = new double[3];
        for(i=0;i<3;i++)
            a[i] = input.nextDouble();
        Arrays.sort(a);
        if((0<a[0]&&a[0]<201)&&(0<a[1]&&a[1]<201)&&(0<a[2]&&a[2]<201))
        {
            if((a[0]+a[1])>a[2])
            {
                if((a[0] == a[1])&&(a[1] == a[2]))
                    System.out.println("Equilateral triangle");
                else if((a[0] == a[1]) && ((a[0]*a[0] + a[1]*a[1]) - (a[2]*a[2]) <0.000001))
                    System.out.println("Isosceles right-angled triangle");
                else if(a[2] == a[1] || a[2] == a[0] || a[0] == a[1])
                    System.out.println("Isosceles triangle");
                else if((a[0]*a[0] + a[1]*a[1]) - (a[2]*a[2]) <0.000001)
                    System.out.println("Right-angled triangle");
                else
                    System.out.println("General triangle");
            }
            else
                System.out.println("Not a triangle");
        }
        else
            System.out.println("Wrong Format");
    }
}

 

　　题目的难度还算简单，但是在写的过程中从同学那听说了Array的库函数，这省下了我还要自己写一遍冒泡排序的功夫（java真是太强了，与此同时我一直都会因为运行超时而无法过测试点在询问班上的大佬后知道是因为java的double属性不像C的double类型会自动给你取小数的后六位，所以我被迫手动确定运算的速度的范围这个运行超时是在是耗费了我不少的时间。（但是库函数的存在似乎也减少了我所需要的时间，塞翁失马焉知非福啊

　　题目集二：7-4

import java.util.Scanner;

public class Main
{
    public static void main(String[] args)
    {
        Scanner input = new Scanner(System.in);
        int year = input.nextInt();
        int month = input.nextInt();
        int day = input.nextInt();
        if(!checkInputValidity(year, month, day))
        {
            System.out.println("Wrong Format");
            System.exit(0);
        }
        nextDate(year,month,day);
        System.exit(0);
    }

    public static boolean isLeapYear(int year)
    {
        return (year % 4 == 0 && year % 100 != 0) || year % 400 == 0;
    }
    public static boolean checkInputValidity(int year,int month,int day)//判断输入日期是否合法，返回布尔值
    {
        return year >= 1820 && year <= 2020 && month >= 1 && month <= 12 && day >= 1 && day <= 31 && (isLeapYear(year) || month != 2 || day <= 28);
    }
    public static void nextDate(int year,int month,int day)  //求输入日期的下一天
    {
        switch (month) {
            case 1, 3, 5, 7, 8, 10 -> {
                if (day == 31)
                    System.out.println("Next date is:" + year + "-" + (month + 1) + "-1");
                else
                    System.out.println("Next date is:" + year + "-" + month + "-" + (day + 1));
            }
            case 2 -> {
                if (isLeapYear(year)) {
                    if (day == 29)
                        System.out.println("Next date is:" + year + "-" + (month + 1) + "-1");
                    else
                        System.out.println("Next date is:" + year + "-" + month + "-" + (day + 1));
                } else {
                    if (day == 28)
                        System.out.println("Next date is:" + year + "-" + (month + 1) + "-1");
                    else
                        System.out.println("Next date is:" + year + "-" + month + "-" + (day + 1));
                }
            }
            case 4, 6, 9, 11 -> {
                if (day == 30)
                    System.out.println("Next date is:" + year + "-" + (month + 1) + "-1");
                else
                    System.out.println("Next date is:" + year + "-" + month + "-" + (day + 1));
            }
            case 12 -> {
                if (day == 31)
                    System.out.println("Next date is:" + (year + 1) + "-1-1");
                else
                    System.out.println("Next date is:" + (year + 1) + "-" + month + "-" + (day + 1));
            }
        }
    }
}

 

　　题目的难度还算简单，但是在日期的情况的考虑过程中耗费了我不少的心思，因为闰年与平年以及二月还有跨年的存在，而我在这里使用的是switch的不断讨论，使我所用的时间大量的增长（要是先写第三题就好了），而这题是我第一次在java中使用多个方法，我发现对于方法的调用实际上与C是相差无几的（C中叫做子函数），与此同时请允许我吐槽一句：idea真是太强了各种帮忙纠错以及改进代码使其更加的简洁，我从中了解了不少新的语句比如：（最开始我写的是if else样式的，被idea简化了）

return year >= 1820 && year <= 2020 && month >= 1 && month <= 12 && day >= 1 && day <= 31 && (isLeapYear(year) || month != 2 || day <= 28);

　　题目集二：7-5

import java.util.Scanner;

public class Main
{
    public static void main(String[] args)
    {
        Scanner input = new Scanner(System.in);
        int year = input.nextInt();
        int month = input.nextInt();
        int day = input.nextInt();
        int n = input.nextInt();
        if(!checkInputValidity(year, month, day, n))
        {
            System.out.println("Wrong Format");
            System.exit(0);
        }
        int[] month_day = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
        int t;
        if (isLeapYear(year)) month_day[1] = 29;
        if(n>=0){
            if(month==1&&day<=n){
                year--;
                month=12;
                if (isLeapYear(year)) month_day[1] = 29;
                else month_day[1]=28;
                day=day+month_day[11]-n;
            }
            else if(day<=n){
                if (isLeapYear(year)) month_day[1] = 29;
                else month_day[1]=28;
                month--;
                day=day+month_day[month-1]-n;
            }
            else {
                day=day-n;
            }
        }
        else {
            int a=n;
            n*=-1;
            if(month==12&&month_day[11]-day<n){
                year++;
                month=1;
                day=-month_day[11]+day+n;
            }
            else if(month_day[month-1]-day<n){
                t=month_day[month-1]-day;
                n-=t;
                day=n;
                month++;
            }
            else {
                day=day+n;
            }
            n=a;
        }
        System.out.println(n+" days ago is:"+year+"-"+month+"-"+day);
    
        System.exit(0);
    }

    public static boolean isLeapYear(int year)
    {
        return (year % 4 == 0 && year % 100 != 0) || year % 400 == 0;
    }
    public static boolean checkInputValidity(int year,int month,int day,int n)
    {
        return year >= 1820 && year <= 2020 && month >= 1 && month <= 12 && day >= 1 && day <= 31 && (isLeapYear(year) || month != 2 || day <= 28)&&n < 11&&n > -11;
    }
    
}

　　题目的难度与前一题相比有一定的提升，因为我一开始的时候一直在用7-4的switch堆叠进行不断的讨论，最后我发现实在计算量太大，被迫放弃。但是在我思考了很久题目给我们的month数组的存在意义的时候我灵稽一动（）的发现我使用switch实在是太蠢了，于是改成了代码中的使用month数组进行定性讨论的方法。通过对于month数组的不断提取以及判定，同时巧妙的引用其他的变量，极大的减少了我的工作量。

　　题目集三：7-2

 

import java.util.Scanner;

public class Main {
   private int year = 0;
   private int month = 0;
   private int day = 0;
   int[] mon_maxnum = new int[]{0,31,28,31,30,31,30,31,31,30,31,30,31};

    public static void main(String[] args)
    {
        Scanner input = new Scanner(System.in);
        Main daily = new Main();
        daily.setYear(input.nextInt());
        daily.setMonth(input.nextInt());
        daily.setDay(input.nextInt());
        if(!checkInputValidity(daily.getYear(), daily.getMonth(), daily.getDay()))
        {
            System.out.println("Date Format is Wrong");
            System.exit(0);
        }
        getNextDate(daily.getYear(), daily.getMonth(), daily.getDay());
    }

    public int getDay() {
        return day;
    }

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

    public int getYear() {
        return year;
    }

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

    public int getMonth() {
        return month;
    }

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

    public int[] getMon_maxnum() {
        return mon_maxnum;
    }

    public void setMon_maxnum(int[] mon_maxnum) {
        this.mon_maxnum = mon_maxnum;
    }
    public static boolean isLeapYear(int year)  //判断闰年
    {
        return (year % 4 == 0 && year % 100 != 0) || year % 400 == 0;
    }
    public static boolean checkInputValidity(int year,int month,int day)//判断输入日期是否合法，返回布尔值
    {
        if(year < 1900||year > 2000||month < 1||month > 12||day < 1||day > 31)
            return false;
        return (!isLeapYear(year) || month != 2 || day <= 29) && (isLeapYear(year) || month != 2 || day <= 28);
    }
    public static void getNextDate(int year,int month,int day)  //求输入日期的下一天
    {
        switch (month) {
            case 1:
            case 3:
            case 5:
            case 7:
            case 8:
            case 10: {
                if (day == 31)
                    System.out.println("Next day is:" + year + "-" + (month + 1) + "-1");
                else
                    System.out.println("Next day is:" + year + "-" + month + "-" + (day + 1));
            }break;
            case 2 : {
                if (isLeapYear(year)) {
                    if (day == 29)
                        System.out.println("Next day is:" + year + "-" + (month + 1) + "-1");
                    else
                        System.out.println("Next day is:" + year + "-" + month + "-" + (day + 1));
                } else {
                    if (day == 28)
                        System.out.println("Next day is:" + year + "-" + (month + 1) + "-1");
                    else
                        System.out.println("Next day is:" + year + "-" + month + "-" + (day + 1));
                }
            }break;
            case 4:
            case 6:
            case 9:
            case 11: {
                if (day == 30)
                    System.out.println("Next day is:" + year + "-" + (month + 1) + "-1");
                else
                    System.out.println("Next day is:" + year + "-" + month + "-" + (day + 1));
            }break;
            case 12 : {
                if (day == 31)
                    System.out.println("Next day is:" + (year + 1) + "-1-1");
                else
                    System.out.println("Next day is:" + year + "-" + month + "-" + (day + 1));
            }break;
        }
    }
}

　　这题实际上就是题目集二7-3的翻版，主要考察了我们对于私有属性的运用，以及set与get方法的使用。在一开始接触私有属性的时候我确实没有搞懂
set与get的实际使用方法，但在看了下idea对其的解释后基本了解了其作用。

　　题目集三：7-3

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

public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        String come = input.nextLine();
        String cleaned = clean(come);
        if(equal(cleaned))
            change(cleaned);
        else
        {
            System.out.println("Wrong Format");
            System.exit(0);
        }
    }
    public static String clean(String come)  //清除存在的空格
    {
        String regEx=" ";
        Pattern p1 = Pattern.compile(regEx);
        Matcher m1 = p1.matcher(come);
        come = m1.replaceAll( "" );
        return come;
    }


    public static boolean equal(String str)  //判断每个段的存在性
    {
        if (str.matches("[+\\-]?"))
            return true;
        else if (str.matches("[\\s]*([1-9][\\d]*[\\s]*\\*[\\s]*x[\\s]*\\^[\\s]*([+\\-]|[\\s]*)[1-9][\\d]*[\\s]*)"))
            return true;
        else if (str.matches("[\\s]*([1-9][\\d]*[\\s]*\\*[\\s]*x[\\s]*)"))
            return true;
        else if (str.matches("[\\s]*([\\s]*x[\\s]*\\^[\\s]*([+\\-]|[\\s]*)[1-9][\\d]*[\\s]*)"))
            return true;
        else if (str.matches("[\\s]*(x[\\s]*)"))
            return true;
        else return str.matches("[\\s]*([1-9][\\d]*)");
    }


    public static void change(String cleaned)
    {
        StringBuilder empty = new StringBuilder();
        Pattern pattern = Pattern.compile("([+\\-]?[1-9][\\d]*\\*x\\^[+\\-]?[1-9][\\d]*)|([+\\-]?[1-9][\\d]*\\*x)|([+\\-]?x\\^[+\\-]?[1-9][\\d]*)|([+\\-]?x)|([+\\-]?[1-9][\\d]*)");
        Matcher matcher = pattern.matcher(cleaned);
        BigInteger str1,str2;
        StringBuilder cleanedBuilder = new StringBuilder(cleaned);
        while (matcher.find())
        {
            String getIt = cleanedBuilder.substring(matcher.start(),matcher.end());
            if (condition1(getIt))
            {
                str1 = BigInteger.valueOf(Long.parseLong(cleanedBuilder.toString().split("\\^")[1]));
                if (getIt.charAt(0) == '-')
                    str2 = BigInteger.valueOf(-1);
                else
                    str2 = BigInteger.valueOf(1);
                if (str2.multiply(str1).compareTo(BigInteger.valueOf(0)) > 0 && !cleanedBuilder.toString().equals(""))
                    cleanedBuilder.append("+");
                if(str1.subtract(BigInteger.valueOf(1)).compareTo(BigInteger.valueOf(1)) > 0 )
                    cleanedBuilder.append(str2.multiply(str1)).append("*x^").append(str1.subtract(BigInteger.valueOf(1)));
                else
                    cleanedBuilder.append(str2.multiply(str1)).append("*x");
            }
            if (condition2(getIt))
            {
                if (!getIt.matches("-x"))
                {
                    if (!empty.toString().equals(""))
                        empty.append("+");
                    empty.append("1");
                }
                else
                    empty.append("-1");
            }
            if (condition4(getIt))
            {
                str2= BigInteger.valueOf(Integer.parseInt(getIt.split("\\*")[0]));
                str1= BigInteger.valueOf(Integer.parseInt(getIt.split("\\^")[1]));
                if (str2.multiply(str1).compareTo(BigInteger.valueOf(0)) > 0&&!empty.toString().equals(""))
                    empty.append("+");
                empty.append(str2.multiply(str1));
                if (str1.subtract(BigInteger.valueOf(1)).compareTo(BigInteger.valueOf(1)) == 0)
                    empty.append("*x");
                else
                    empty.append("*x^").append(str1.subtract(BigInteger.valueOf(1)));
            }
        }
    }
    public static boolean condition1(String input)
    {
        if (input.matches("([+\\-])?x\\^([+\\-])?([1-9][\\d]*)"))
            return true;
        else
            return false;
    }
    public static boolean condition2(String input)
    {
        if (input.matches("([+\\-])?x"))
            return true;
        else
            return false;
    }
    public static boolean condition3(String input)
    {
        if (input.matches("([+\\-])?([1-9][\\d]*)\\*x"))
            return true;
        else
            return false;
    }
    public static boolean condition4(String input)
    {
        if (input.matches("([+\\-])?(([1-9][\\d]*)\\*x\\^([+\\-])?([1-9][\\d]*))"))
            return true;
        else
            return false;
    }
}

　　这题是我感觉既遗憾又不遗憾的一题，在我思考这题的解法的3天内，我思考了不少理论上可行的方法，包括：1.强行通过split（+-）拆分出各种字符串
然后一个一个的进行检测与运算然后再重组，但是这种因为难以检测错误输入而且实在太复杂被丢垃圾桶。2.将输入的拆分成一个一个字符并且重组为形式符
合要求的然后再计算，但是因为重组的过程态复制而丢垃圾桶。最后我选择了我先在所展示的这种方法，拆分出 +- 前后的字符，然后通过四种正确的形式进
行判断，然后再单独的讨论以及重组。其中运用到了
import java.util.regex.Matcher;   import java.util.regex.Pattern;  import java.math.BigInteger；这三个库，matcher与pattern都是通过正则表达式来进行大量的判断。compile(String regex) 将正则表达式编译到Pattern中，该方法是个静态方法pattern() 

返回正则表达式的字符串形式,其实就是返回Pattern.complile(String regex)的regex参数。在我大致的了解到他们的使用方法，并且与同学进行了深入而深刻
的交流后我便用一天的时间完成了上述的代码，但是其中计算的部分并不完善，而我却无法通过调试来检查到我的错误，说明我的代码中肯定存在某些我现有的
知识无法理解的错误。这便是我最大的遗憾，但是我不遗憾的是我尽了最大的努力，并且学会了不少课外的姿势。（结论：菜得真实
　　

3、踩坑心得
　　1.java拥有巨量而强大的库函数而我并没有去大量的了解，这使得我不少的时候走了弯路，需要我多多通过查询资料以及询问身边的大佬来了解我的错误。

 

 

 

 

 

　　2.我的代码有些时候还是不能跳出C的简单思维，比如喜欢将所有的方法与类写在一段代码中最后形成了一段极其长的代码，在我询问了老师后了解到我应
该要学会多分类并通过类之间的调用，能大大提高可读性。
　　3.写代码的使用经常顾此失彼,比如下图的讨论的过程中，我太极限的想要降低自己的内存占用，导致可读性很低

 

 

在多种情况的讨论时我也经常会少考虑不少东西，下图的二月的部分就花了我不少的时间进行调试，最后的结果都是我自己没有考虑完美

 

 

4、改进建议
　　
针对题目一：7-8下图的代码实际上可以通过控制条件以及通过偏向C的代码来进行改进可读性

 

 

 

 

 

题目集二：7-4、7-5如果可以使用java中强大的日期类库的话可以用更少的代码完成功能并且做到大区间的大量计算而且性价比比我的本身的多重判断更加高。
题目集三：7-2可以增加一个类来专门来对日期进行计算与计数，而有益于增加其他的功能。
题目集三：7-3我应该可以通过简化我的main来增加可读性，并且通过增加更多的condition来实现更加复杂的多项式求导。

5、总结
通过三次题目集的综合性学习，我对java的基本操作以及面向对象的思想有了基本的理解，在日后的学习中我应该加强我对java库函数的了解范围，使自己的
工作效率得到提高，同时跟随老师的步伐一步一个脚印的深入学习java的多方面知识协调共进，查漏补缺。
同时我希望老师能适当的放宽作业的提交期限，因为有些时候时间实在是不够。对于老师上课所讲的我都感觉非常的深入而深刻，对我学习java，查漏补缺方面
都有很大的作用，同时我希望老师实验课的时候能多观察我们编程时碰到的难点，然后有针对性的提出建设性的建议。