一、前言：
学习OOP课程的第一阶段已经结束了，也由于在此阶段能力有限，在此进行对于知识点，题量，以及题目难度的个人看法，仅供大家参考。
二、3次作业概况
（1）第一次作业
主要是让我们学习Java的基本语法：输入输出，if语句，for循环，字符串比较，创建数组，运用选择排序，一些基本的类及其方法等，主要让我们学习实践的也是编程的语法，题目相对简单容易，题量中等，难度较低。
（2）第二次作业
难度相对提高，需要自己去学习新的知识点：进制转换，字符串截取，sort排序，利用boolean判断是否闰年，日期是否合法；考虑闰年的不同月份的不同情况等，以及了解了一些java类与方法的关系，加深考察编程的细节；日期问题的迭代，注重基本的问题分析。题量中等，难度较低
（3）第三次作业
开始展现出与C语言不同的编程方式以及java的一些面向对象的概念，注重构造类，运用类，涉及到了类的封装性，多个类的写法；运用正则表达式；字符串截取的表达方式；动态数组的使用。题量小，前两道题的难度适中，但最后一道题难度极大，花费许多时间写出来。
类的使用，是在第二次作业的基础上，锦上添花。但第三道题，难度急剧上升。难的原因在于四点：第一是需要学习正则表达式才能最高效的完成该题；第二是知识点的综合运用，不仅仅需要类的知识，还需要大数，字符匹配，替代等方法去辅助题目的完成，其中许多的细节性的问题难以把控。第三是题目测试点的问题，花了时间在钻题目测试点的牛角尖，而没去仔细阅读指导书，导致许多时间浪费在合法性测试上。这样更加让自己认识到自己所学的一切还是太少了，需要在下一阶段高强度学习。
第一次题目集：7-8
1.设计与分析
题目集01 7-8 的题目为判断三角形类型，考察的是对整型.实型数据的处理和选择语句的综合使用。
整体思路介绍
1.题目集01 7-8 从思路上理解起来很清晰，三角形之间是包含关系，通过if-else结构层层筛选。
2.本题只涉及到输入三角形的三条边的边长，通过判断三边关系来确定三角形的类型。
3.题目考察的三角形类型为:直角三角形，等腰直角三角形，等腰三角形，等边三角形，一般三角形。
4.通过多个 if 语句判断三角形类型。题目输入的范围是[1,200]，故数据类型定义为double。
5.double 型的数据在进行平方计算时会丢失精度导致无法判断是否为直角三角形，所以需判断某边的平方减去另外两边平方和的结果小于0.0001即可。
if ((a >= 1 && a <= 200) && (b >= 1 && b <= 200) && c >= 1 && c <= 200) {
if (a + b > c && a + c > b && b + c > a) {
if (a == b && a == c) {
System.out.println("Equilateral triangle");
} else {
if (a == b || b == c || a == c) {
if ((a * a + b * b - c * c < 0.0001) || (a * a + c * c - b * b < 0.0001) || (b * b + c * c - a * a < 0.0001)) {
System.out.println("Isosceles right-angled triangle");
} else
System.out.println("Isosceles triangle");
} else {
if ((a * a + b * b - c * c < 0.0001) || (a * a + c * c - b * b < 0.0001) || (b * b + c * c - a * a < 0.0001)) {
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");
图分析
根据PowerDesigner的类图显示，该题只有一个Main类，代码结构较为简单。
圈复杂度分析使用 SourceMonitor 软件
圈复杂度很高，是因为这题用了多个if else语句还有很多并或连接，导致复杂度很高，代码状况复杂。
2.踩坑心得
以此部分为例子，但凡判断直角三角形情况，都需要去用勾股定理进行计算判断，而最开始的设计便是勾股定理的等式设计，导致输出结果有误，后查找其他博客的资料发现，Java中浮点计算存在精度丢失问题，若通过等式去验证勾股定理，则会导致浮点计算错误，验证失败。后调试为<0.0001(小数点几位都可以），则可以通过直角三角形的验证。我没有考虑三边的关系，以及各个种类三角形之间的关系，会导致我没有考虑周全，漏掉判断情况，且最开始的if也全都是分开讨论的，后面才做稍微的优化。
3.改进建议
减少if语句的使用，为降低复杂度，if-else语句在某些情况可用switch-case结构或数组赋初始值的形式表达，使代码更为简洁，可读性更强。
第二次题目集：7-4
1.设计与分析：
整体思路介绍
要求输入年月日的值（均为整型数），输出该日期的下一天。数据类型均为整型数,设输入 year - month - day。
首先设计非法输入，令boolean checkInputValidity = true;如果输入范围不在题目要求的范围内，在此注意闰年1月，2月，7月，8月和每月的边界情况，返回false，否则返回true
public static boolean checkInputValidity(int year,int month,int day){//判断输入日期是否合法，返回布尔值
if((year>=1820&&year<=2020)&&(month>=1&&month<=12)&&(day>=1&&day<=31)){
return true;
}else
return false;
}
接下来就是判断是否闰年，这里利用闰年数a，a%4= =0 && a%100!=0 || a%400= =0判断是否成立，为后续的日期数据的判断打下基础。
public static boolean isLeapYear(int year) {
if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) {
return true;
} else
return false;
}
最后就是通过if语序进行严密的逻辑讨论：闰年2月到29号，平年到28号就进入下一月份；跨年12月到31号就结束一年进入下一年，并且月份变为1；再考虑大月和小月的问题。
public static void nextDate(int year,int month,int day) {//求输入日期的下一天
if(isLeapYear(year)){//是闰年
if(month==2&&day==29){
month=3;
System.out.println("Next date is:"+year+'-'+month+'-'+1);
}else if(((month%2==1&&month<8)||month==8||month==10)&&day==31){
month=month+1;
System.out.println("Next date is:"+year+'-'+month+'-'+1);
}else if(((month%2==0&&month<7)||month==9||month==11)&&day==30){
month=month+1;
System.out.println("Next date is:"+year+'-'+month+'-'+1);
}else if(month==12&&day==31){
year=year+1;
System.out.println("Next date is:"+year+'-'+1+'-'+1);
}else{
System.out.println("Next date is:"+year+'-'+month+'-'+(day+1));
}
}else {//不是闰年
if(month==2&&day==28){
month=3;
System.out.println("Next date is:"+year+'-'+month+'-'+1);
}else if(((month%2==1&&month<8)||month==8||month==10)&&day==31){
month=month+1;
System.out.println("Next date is:"+year+'-'+month+'-'+1);
}else if(((month%2==0&&month<7)||month==9||month==11)&&day==30){
month=month+1;
System.out.println("Next date is:"+year+'-'+month+'-'+1);
}else if(month==12&&day==31){
year=year+1;
System.out.println("Next date is:"+year+'-'+1+'-'+1);
}else{
System.out.println("Next date is:"+year+'-'+month+'-'+(day+1));
}
}
}
分析
使用SourceMonitor对该函数的复杂度进行检测，结果如下：
SourceMonitor的生成报表：
根据PowerDesigner的类图显示，该题只有一个类，但利用了三个方法：
此题复杂度较高，代码状况非常复杂，原因还是if语句过多。
2.踩坑心得：
特殊月份的特殊情况没有想到：（这里pta的测试点起到了很大的作用）；还有就是一直大小月的判断表达有误，输出也会有错，其实此题题目并不难，总之一句话，这道题只要足够细心，考虑周全，一次过还是可以的。经过这题，我对闰年月份的判断熟练了不少。
3.改进建议
第一，判断是否闰年没有应该写在最上面，体现逻辑的严密性，这里我将其写在第二块，复盘时觉得代码逻辑显得有点不够严谨。
第二，其实本题完全没必要写那么多的if和else，如果想到用int[] monthDate = { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }，并且把能和起来的条件用“||”和“&&”表示在一个if里面会降低很多复杂度，同时也会减少丢失考虑情况的误差.
7-5
1.设计与分析
题目整体思路
该作业的要求输入年月日的值（均为整型数），同时输入一个取值范围在[-10,10]之间的整型数n，输出该日期的前n天（当n > 0时）、该日期的后n天（当n<0时）。
此题和上题判断非法输入和是否闰年的方式一样，首先设计非法输入，令boolean checkInputValidity = true;如果输入范围不在题目要求的范围内，在此注意闰年1月，2月，3月初，7月，8月初，9月初和每月的边界，跨年的情况，返回false，否则返回true；
public static boolean checkInputValidity(int year, int month, int day, int n) {//判断输入日期是否合法，返回布尔值
if ((year >= 1820 && year <= 2020) && (month >= 1 && month <= 12) && (day >= 1 && day <= 31) && (n >= -10 && n <= 10)) {
return true;
} else
return false;
}
判断是否为闰年
public static boolean isLeapYear(int year) {
if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) {
return true;
} else
return false;
}
最后通过if语序进行判断：
闰年2月到29号，平年到28号，若输入为负就进入下一月份；
当3月初输入正数则回到2月，且日期是从29或28号开始相减；
8月和9月输入正数都是从上一月的31号开始减；
跨年12月到31号输入正数就结束一年进入下一年，并且月份变为1；
再考虑大月和小月的问题。
public static void nextnDate(int year, int month, int day, int n) {//求输入日期的下一天
if(n==0){
System.out.println("0 days ago is:"+year+'-'+month+'-'+day);
}else if (n > 0) {
if (isLeapYear(year)) {//是闰年
if (month == 3 && day - n <= 0) {
System.out.println(n + " days ago is:" + year + '-' + 2 + '-' + (29+day-n));
} else if (((month > 1 && month % 2 == 1 && month < 8) || month == 10) && day - n <= 0) {
System.out.println(n + " days ago is:" + year + '-' + (month - 1) + '-' + (30+day-n));
} else if (((month % 2 == 0 && month < 9) || month == 9 || month == 11) && day - n <= 0) {
System.out.println(n + " days ago is:" + year + '-' + (month - 1) + '-' + (31+day-n));
} else if (month == 1 && day - n <= 0) {
System.out.println(n + " days ago is:" + (year - 1) + '-' + 12 + '-' + (31+day-n));
} else {
System.out.println(n + " days ago is:" + year + '-' + month + '-' + (day - n));
}
} else {//不是闰年
if (month == 3 && day - n <= 0) {
System.out.println(n + " days ago is:" + year + '-' + 2 + '-' + (28+day-n));
} else if (((month > 1 && month % 2 == 1 && month < 8) || month == 10) && day - n <= 0) {
System.out.println(n + " days ago is:" + year + '-' + (month - 1) + '-' + (30+day-n));
} else if (((month % 2 == 0 && month < 9) || month == 9 || month == 11) && day - n <= 0) {
System.out.println(n + " days ago is:" + year + '-' + (month - 1) + '-' + (31+day-n));
} else if (month == 1 && day - n <= 0) {
System.out.println(n + " days ago is:" + (year - 1) + '-' + 12 + '-' + (31+day-n));
} else {
System.out.println(n + " days ago is:" + year + '-' + month + '-' + (day - n));
}
}
}else{
if (isLeapYear(year)) {//是闰年
if (month == 2) {
System.out.println(n + " days ago is:" + year + '-' + 3 + '-' + (day-n-29));
} else if (( month % 2 == 1 && month < 9)|| month == 10) {
System.out.println(n + " days ago is:" + year + '-' + (month + 1) + '-' + (day-n-31));
} else if (month == 4 || month ==6 || month == 9 || month == 11) {
System.out.println(n + " days ago is:" + year + '-' + (month + 1) + '-' + (day-n-30));
} else if (month == 12) {
System.out.println(n + " days ago is:" + (year + 1) + '-' + 1 + '-' + (day-n-31));
} else {
System.out.println(n + " days ago is:" + year + '-' + month + '-' + (day-n));
}
} else {//不是闰年
if (month == 2) {
System.out.println(n + " days ago is:" + year + '-' + 3 + '-' + (day-n-28));
} else if (( month % 2 == 1 && month < 9)|| month == 10) {
System.out.println(n + " days ago is:" + year + '-' + (month + 1) + '-' + (day-n-31));
} else if (month == 4 || month ==6 || month == 9 || month == 11) {
System.out.println(n + " days ago is:" + year + '-' + (month + 1) + '-' + (day-n-30));
} else if (month == 12) {
System.out.println(n + " days ago is:" + (year + 1) + '-' + 1 + '-' + (day-n-31));
} else {
System.out.println(n + " days ago is:" + year + '-' + month + '-' + (day-n));
}
}
}
}
分析
根据PowerDesigner的类图显示，该题只有一个类，但利用了三个方法。
使用SourceMonitor对该函数的复杂度进行检测，结果如下：
SourceMonitor的生成报表：
此题和上题一样，复杂度较高，代码状况异常复杂
2.踩坑心得
这题值得注意的是，当用户输入为负数时，实则是日期前推，输入为正时，则为减；经过了第四题，其他应该就没什么问题了。
3.改进建议
同上一题一样，最好改为数组的形式，如果怕if语句中的条件太过复杂，还是可以选择拆开写的虽然复杂度相比较高，但是代码看起来较为易懂。
题目集三：7-2
1.设计与分析
题目整体思路
该作业的要求是定义一个类Date，包含三个私有属性年（year）、月（month）、日（day），均为整型数。
此题由提供的类图可知，需要我们重新构建一个新的Date类，Date date=new Date(year,month,day);并且对year month day 三个属性进行封装变为私有属性，同时构造有参和无参来进行传输数据，用get和set方法将其进行调用如下：
class Date{
private int year;
private int month;
private int day;
int[] mon_maxnum=new int[]{0,31,29,31,30,31,30,31,31,30,31,30,31};
public Date() {
int year;
int month;
int day;
}
public Date(int year, int month, int day) {
this.setYear(year);
this.setMonth(month);
this.setDay(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 getDay() {
return day;
}
public void setDay(int day) {
this.day = day;
}
在搭建好结构后，接下来就是和上面两题差不多的思路，判断闰年，输入是否合法以及特殊月份特殊日期的判断。这里相比上面两道题较为优化的是day的数目直接存入数组中，if中的条件判断较为简单了。
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[] mon=new int[]{0,31,28,31,30,31,30,31,31,30,31,30,31};
if(isLeapYear(year))
mon[2]=29;
return year>=1900&&year<=2000&&month>0&&month<=12&&day>0&&day<=mon[month];
}
public static void getNextDay(int year, int month, int day){
int[] mon=new int[]{0,31,28,21,30,31,30,31,31,30,31,30,31};
if(isLeapYear(year)) mon[2] = 29;
if(isLeapYear(year)){
if(month==12&&day==31){
System.out.println("Next day is:"+(year+1)+'-'+1+'-'+1);
}else if(mon[month]==day){
System.out.println("Next day is:"+year+'-'+(month+1)+'-'+1);
}else{
System.out.println("Next day is:"+year+'-'+month+'-'+(day+1));
}
}else{
if(mon[2]==29){
System.out.println("Date Format is Wrong");
}if(month==12&&day==31){
System.out.println("Next day is:"+(year+1)+'-'+1+'-'+1);
}else if(mon[month]==day){
System.out.println("Next day is:"+year+'-'+(month+1)+'-'+1);
}else{
System.out.println("Next day is:"+year+'-'+month+'-'+(day+1));
}
}
}
}
分析
根据PowerDesigner的类图显示，直观地看出，该题涉及了两个类Date和Main，利用了多个方法：
使用SourceMonitor对该函数的复杂度进行检测，结果如下：
SourceMonitor的生成报表：
由图，代码复杂度依旧很高
2.踩坑心得
这次的作业主要是搭建类来解决问题，要学习类的创建，但最开始以为和前面的题差不多，但是后来发现创建类的方式确实简易许多，代码可读性更高了，使用数组存储各个月的天数后，判断的表达式也更简洁，if-else和&&或||的使用也更少，但是复杂度仍然很高。
3.改进建议
同样还是在大块的if-else语句中进行优化和修改吧，其实在if（）里的判断条件里，我也在尽力简化，至于其他的修改及方式，我还在努力学习当中，我相信通过日后的学习与练习会使代码更加优化简洁的。
7-3
1.设计与分析
整体思路
该题的要求是编写程序性，实现对简单多项式的导函数进行求解。同时还要满足以下要求
·当某一项为“0”时，则该项不需要显示，但如果整个导函数结果为“0”时，则显示为“0”；
·当输出结果第一项系数符号为“+”时，不输出“+”；
·当指数符号为“+”时，不输出“+”；
·当指数值为“0”时，则不需要输出“x^0”，只需要输出其系数即可。
public class Main {
public static void main(String[] args) {
Polynomial polynomial=new Polynomial();
Scanner input=new Scanner(System.in);
polynomial.setFormulal(input.nextLine().replace(" ",""));
int t= polynomial.constant(polynomial.getFormulal());
String c3[] = new String[1000];
String c1[] = new String[1000];
String c2[] = new String[1000];
int[] data1 = new int[100000];
int k = 0;
int k1 = 0;
int k2 = 0;
int k3 = 0;
int k_3 = 0;
int i = 0;
int j = 0;
int n = 0;
String strn = "*x^";
String str = null;
int ture = 0;
String str2[] = new String[1000];
String str3[] = new String[1000];
String str4[] = new String[1000];
String str6 = null;
String pattern = "([+-]?[0-9]+?\\*?[x]\\^[+-]?[0-9]+)";
String pattern1 ="([+-]?[0-9]*\\*?[x]\\^[+-]?[0-9]+)";
String pattern2 = "([+-]?[0-9]*\\*?[x])";
String pattern3 = "([0-9]+)";
Pattern r3 = Pattern.compile(pattern3);
Matcher m3 = r3.matcher(polynomial.getFormulal());
int ture_1 = 0;
while (m3.find( )) {
c3[k_3] = m3.group();
k_3++;
}
for(i = 0;i < k_3; i++) {
if(c3[i].charAt(0) == '0') {
ture--;
}
}
for(i = 0; i < polynomial.getFormulal().length(); i++) {
if(polynomial.getFormulal().charAt(i) == 'x') {
ture_1++;
}
}
if(ture == 0 && ture_1 > 0) {
int f = 0;
int f1 = 1;
int f2 = 2;
if(polynomial.getFormulal().charAt( polynomial.getFormulal().length() - 1) != 'x') {
for(i = 0; i < polynomial.getFormulal().length(); i++) {
if(polynomial.getFormulal().charAt(i) == 'x' && polynomial.getFormulal().charAt(i+1) == '^') {
data1[f] = f1;
f++;
}
else if(polynomial.getFormulal().charAt(i) == 'x' && polynomial.getFormulal().charAt(i + 1) != '^') {
data1[f] = f2;
f++;
}
}
}
else {
for(i = 0; i < polynomial.getFormulal().length()-1; i++) {
if(polynomial.getFormulal().charAt(i) == 'x' && polynomial.getFormulal().charAt(i+1) == '^') {
data1[f] = f1;
f++;
}
else if(polynomial.getFormulal().charAt(i) == 'x' && polynomial.getFormulal().charAt(i + 1) != '^') {
data1[f] = f2;
f++;
}
}
data1[f] = f2;
}
// 创建 Pattern 对象
Pattern r = Pattern.compile(pattern);
Pattern r1 = Pattern.compile(pattern1);
// 现在创建 matcher 对象
Matcher m1 = r1.matcher(polynomial.getFormulal());
while (m1.find( )) {
c1[k1] = m1.group();
k1++;
}
//将x的系数字符取出转化为数字存储在data[]数组中
for(j = 0; j < k1; j++) {
if(c1[j].charAt(0) == 'x' && c1[j].charAt(1) == '^') {
BigInteger num_1 = new BigInteger("1");
BigInteger num = new BigInteger("1");//x的系数
BigInteger num1 = new BigInteger(c1[j].substring(2, c1[j].length()));//x的次方
str2[j] = String.valueOf(num1.subtract(num_1));//x次方减一
str3[j] = String.valueOf(num.multiply(num1));//x的系数与次方相乘
}
else if(c1[j].charAt(0) == '-' && c1[j].charAt(1) == 'x' && c1[j].charAt(2) == '^') {
BigInteger num_1 = new BigInteger("1");
BigInteger num = new BigInteger("-1");//x的系数
BigInteger num1 = new BigInteger(c1[j].substring(3, c1[j].length()));//x的次方
str2[j] = String.valueOf(num1.subtract(num_1));//x次方减一
str3[j] = String.valueOf(num.multiply(num1));//x的系数与次方相乘
}
else if(c1[j].charAt(0) == '+' && c1[j].charAt(1) == 'x' && c1[j].charAt(2) == '^') {
BigInteger num_1 = new BigInteger("1");
BigInteger num = new BigInteger("1");//x的系数
BigInteger num1 = new BigInteger(c1[j].substring(3, c1[j].length()));//x的次方
str2[j] = String.valueOf(num1.subtract(num_1));//x次方减一
str3[j] = String.valueOf(num.multiply(num1));//x的系数与次方相乘
}
else {
for(n = 0; n < c1[j].length(); n++) {
if (c1[j].charAt(n) == '*' && c1[j].charAt(n+2) == '^') {
if(n > 1) {
BigInteger num_1 = new BigInteger("1");
BigInteger num = new BigInteger(c1[j].substring(0, n));//x的系数
BigInteger num1 = new BigInteger(c1[j].substring(n+3, c1[j].length()));//x的次方
str2[j] = String.valueOf(num1.subtract(num_1));//x次方减一
str3[j] = String.valueOf(num.multiply(num1));//x的系数与次方相乘
}
else {
BigInteger num_1 = new BigInteger("1");
BigInteger num = new BigInteger(c1[j].substring(0, 1));
BigInteger num1 = new BigInteger(c1[j].substring(4, c1[j].length()));
str2[j] = String.valueOf(num1.subtract(num_1));
str3[j] = String.valueOf(num.multiply(num1));//x的系数与次方相乘
}
}
}
}
}
Pattern r2 = Pattern.compile(pattern2);
Matcher m2 = r2.matcher(polynomial.getFormulal());
while (m2.find( )) {
c2[k2] = m2.group();
k2++;
}
//System.out.println(k2);
//将一次函数系数存储到数组str4中
for(i = 0; i < k2; i++) {
if(data1[i] == 2) {
if(c2[i].charAt(0) == 'x') {
str4[i] = "1";
}
else if(c2[i].charAt(1) == 'x' && c2[i].charAt(0) == '+') {
str4[i] = "+1";
}
else if(c2[i].charAt(1) == 'x' && c2[i].charAt(0) == '-') {
str4[i] = "-1";
}
else {
for(n = 0; n < c2[i].length(); n++) {
if(c2[i].charAt(n) == '*' ) {
BigInteger num4 = new BigInteger(c2[i].substring(0, n));
str4[i] = String.valueOf(num4);
}
}
}
}
}
int l = 0;
for(i = 0; i < k2; i++) {
if(data1[i] == 1) {
if(i == 0) {
str6 = str3[l] + strn + str2[l];
l++;
}
if(i > 0) {
if(str3[l].charAt(0) != '-') {
str6 = str6 + "+" + str3[l] + strn +str2[l];
l++;
}
else {
str6 = str6 + str3[l] + strn +str2[l];
l++;
}
}
}
if(i == 0 && data1[i] == 2) {
str6 = str4[i];
}else if(i > 0 && data1[i] == 2 && data1[i - 1] == 2) {
str6 = str6 + str4[i];
}else if(i > 0 && data1[i] == 2 && data1[i - 1] != 2) {
if(str4[i].charAt(0) != '-') {
str6 = str6 + str4[i];
}
else {
str6 = str6 + str4[i];
}
}
}
System.out.println(str6);
}
else if(ture ==0 && ture_1 == 0) {
System.out.println("0");
}else if(t==0)
System.out.println("Wrong Format");
}
}
分析
使用SourceMonitor对该函数的复杂度进行检测，结果如下：
SourceMonitor的生成报表：
2.踩坑心得
1.
该处正则表达式是不规范的，它所能匹配到的是单个多项式，但问题出在若出现x项或者中间出现常数项，则会匹配出错，这让我改变的写法。改变写法如下：
2.
因没有仔细阅读指导书，则在一个多项式中出现多个一次幂多项式求导时，会出现常见的写法如下：
而所需要的合法性检验的写法却如下：
虽然不符合平常写法，但这是指导书中所提示的，因为这个合法性测试，不知道怎么解决问题，后发现问题因于此。
3.改进建议
本次代码我使用的类设计还是略微简陋的，虽然都有很明确的分工，但是只有一个主类，也没进行类分工。并且在开头为负数的测试点上，我的代码也是一直无法通过，这是令人痛苦的，痛苦在自己的代码虽然进行了类的分工，但却不知出在哪一步上。在通过上一次实验发现，这其实可以用断点调试的方式，去看到进程哪一步出错。其次则是在正则表达式上，本人的正则表达式多少还存在点缺陷，例如中间出现常数，则极大可能出现无正确结果的现象。经过思考，发现其实可以在拆分处多个单项式时，便开始进行求导处理，处理完一项再去处理下一项，最后连结起来。而我所做的代码，则太关注于对指数与系数的细节处理，以至于大体的求导，会容易出错。最后就是类设计的缺陷，本人类设计基础也是初学者水平，在了解到类与类之间的多种关系后，发现该代码类间关系过于简单，这也是出错较多的原由，后续应当将类联系起来。
总结
首先在第一阶段的学习中，做作业也是通过循序渐进的方式从开始认识Java再到本阶段的重点---类设计。学习的东西虽然基础，但是掌握却需要大量联系与自己的思考。从最基本的语法认知，到主动自己上网查找所需要功能的写法，再到初入Java面向对象编程的基本---类设计，这带给我们的是从以前C语言编程到Java语言编程习惯的改变。作为初学者，发现还有许多东西需要去掌握：
1.类与类之间的关系，当能够了解，并运用掌握类与类之间的关系，则能解决大多数问题，许多时候正是不知如何进行将类互相呼应，导致题目卡壳，写不出，这可能就是这门课的难点
2.需要学习许多Java语言中本身包含的类与方法，需要我抽出时间学习，并在日后学以致用，这样既可以减轻代码冗余，又可以降低圈复杂度
3.在编程过程中，要有应用类的概念，构造出框架，进行分工，在实现时要尽量提高代码的可读性，减少垃圾代码，降低复杂度
4.基础语法的巩固，在进行Java编程中，时常脱离不出C语言的习惯，导致出现语法错误，甚至不记得如何进行编写，这需要在练习中，不要只会对之前自己写的代码复制粘贴，还要留意写法。
最后就是希望自己在总结中提升，不断学习与进步，感谢老师的指导与作业监督，虽然过程很累并且有点困难，但是还得积极面对第二阶段可能更困难的学习！！！
