· 前言：

         1.题目集一前言

         本次题目共分9到练习题，分别考察判断、循环、数组的建立、运用，加强了我对数组中数据的应用、查找、判断，题目集一的难度相对比较简单一些，非是困难程度，题目集一是侧重于对基础知识点的掌握，加强了我的java基础。

         2.题目集二前言

         第二次的题目集为3道练习题，本次3题的难度大于题目集一题目的难度，其中知识的考查包括题目集一知识，多些为数组中转化的运用，指定数组输出，判断指定输出，内容判断，内容提取等等，练习程序多种运用写法，加强运用性，本次题目集的重点为第二题，本题目的难度略大于其他题目难度，起初并不知道如何去写，在书上学习和上网查询后也掌握了后了解怎样进行编程，考察了我们对于字符串数组，以及字符串.length（）方法的用法，相对简单，本次题目加强了我对java的多方面运用，对java用法更灵活。

        3.题目集三前言

        题目集三题目为3道练习题，本次题目集的难度高于前两次的题目集难度，考察坐标的输入问题，对数据中数组的读取，第一题的难度主要为点与点之间距离计算，与输入"+，-"的坐标判断并能否运行，解决后其他难度就降低了，第二，第三题的主要问题和第一题基本一样，判断不同，为点线距离问题，三角形判断问题，考察多态性以及使用方法，本题目集的第二，第三题的难度相对第一题难度有所提高，主要考察我们对所建立的使用与调用问题。

·让我对类的聚合关系理解更加深刻，还有类的继承和多态，本次考察主要向我们渗透了一些关于Java的设计原则，让我们能更加深刻的思考类与类之间的关系，从而深入的了解面向对象的设计原则，这些都是这三次习题集考察的亮点。

· 设计与分析：

import java.util.Scanner;
 
public class Main {
 
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String a = in.next();
        if(a.length()<11) {
            System.out.print("null data");
            return;
        }
        if(a.matches("^[1]*$")) {
            System.out.print("null data");
            return;
        }
        int start = 0,i=0,num = 1,sum = 0;
        boolean parity = false,validate = false;
        for(start = 0;start<a.length()-10;start++) {
            if(a.charAt(start)=='0') {
                System.out.print(num+":");
                num++;
                if(a.charAt(start+10)=='0') {
                    validate = false;
                }else {
                    validate = true;
                    sum = 0;
                    for(i=start+1;i<start+9;i++) {
                        if(a.charAt(i)=='1') {
                            sum++;
                        }
                    }
                    if(sum%2==0) {
                        if(a.charAt(start+9)=='1') {
                            parity = true;
                        }else {
                            parity = false;
                        }
                    }else {
                        if(a.charAt(start+9)=='0') {
                            parity = true;
                        }else {
                            parity = false;
                        }
                    }
                }
                if(validate == true) {
                    if(parity == true) {
                        for(i=start+1;i<start+9;i++) {
                            System.out.print(a.charAt(i));
                        }
                        System.out.print("\n");
                    }else {
                        System.out.println("parity check error");
                    }
                }else {
                    System.out.println("validate error");
                }
                start  = start + 10;
            }
        }
    }
}

本代码为题目集二7-2，本题题目由0、1组成的二进制数据流，我对这道题的每一步基本都有Blog，操作的时候很困难，起初不知道怎么编程，后面看书和在网上查找像是问题，并问了些同学，得以解决。

此题大部分运用数组并对数组中数据的查找，数组的储存，中字符串的调用，输出等等。

下面是我从网上寻找的降低圈复杂度的方法，在今后的学习或者在解决PTA题目时会学着慢慢的渗透和尝试降低圈复杂度的方法。

Composing Methods（重新组织你的函数）

Extract Method（提炼函数）

Substitute Algorithm（替换你的算法）

import java.util.Scanner;

public class pta9 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String tokenString = new String(scanner.nextLine());
        if (judgment(tokenString)) {
            System.out.println("Wrong Format");
            return;
        }
        switch (tokenString.charAt(0)) {
        case '1':
            case1(tokenString);
            break;
        default:
            System.out.println("Wrong Format");
            break;
        }

    }

    public static boolean judgment(String tokens) {
        final int NUM = 40;
        point[] newPoints = new point[NUM]; // 用来存储
        newPoints[0] = null;
        newPoints[1] = null;
        for (int i = 2; i < NUM / 2; i++) {
            newPoints[i] = new point();
        }
        boolean flag = false;
        int first = 2;
        int number = 2;
        for (int i = 2; i < tokens.length(); i++) {
            if (tokens.charAt(i) == ' ') {
                newPoints[number].fun(tokens.substring(first, i));
                first = i + 1;
                number++;
            }
        }
        newPoints[number].fun(tokens.substring(first, tokens.length())); // 判断
        for (int i = 2; i <= number; i++) {
            if (newPoints[i].flag == false) {
                flag = true;
                break;
            }

        }
        return flag;
    }

    public static void case1(String tokenString) {
        int cnt = 0;
        for (int i = 0; i < tokenString.length(); i++) {
    if (tokenString.charAt(i) == ',') {
                cnt++;
            }
        }
        if (cnt > 3) {
            System.out.println("wrong number of points");
        } else {
            int i, flag = 0;
            int num = 0;
            String[] s = new String[6];
            for (i = 2; i < tokenString.length(); i++) {
                if (tokenString.charAt(i) == '+' || tokenString.charAt(i) == '-'
                        || (tokenString.charAt(i) >= '0' && tokenString.charAt(i) <= '9')) {
                    for (int j = i; j < tokenString.length(); j++) {
                        if (tokenString.charAt(j) == ',' || tokenString.charAt(j) == ' ') {
                            if ((j + 1) != tokenString.length()) {
                                s[num] = tokenString.substring(i, j);
                                flag = j;
                                num++;
                                i = j;
                                break;
                            }
                        }
                    }
                }
            }
            if (tokenString.charAt(i - 1) == ' ') {
                i--;
            }
            s[5] = tokenString.substring(flag + 1, i);
            double x1, y1, x2, y2, x3, y3;
            x1 = Double.parseDouble(s[0]);
            y1 = Double.parseDouble(s[1]);
            x2 = Double.parseDouble(s[2]);
            y2 = Double.parseDouble(s[3]);
            x3 = Double.parseDouble(s[4]);
            y3 = Double.parseDouble(s[5]);
            double a = Math.sqrt(Math.pow(x1 - x2, 2) + Math.pow(y1 - y2, 2));
            double b = Math.sqrt(Math.pow(x2 - x3, 2)) + Math.pow(y2 - y3, 2);
            double c = Math.sqrt(Math.pow(x1 - x3, 2)) + Math.pow(y1 - y3, 2);
            traingle(a, b, c);
        }

    }

    public static void traingle(double a, double b, double c) {
        if ((a + b > c && a + c > b && b + c > a)) {
            if (a == b || a == c || b == c) {
                if (a == b && a == c) {
                    System.out.println(true + " " + true);
                } else {
                    System.out.println(true + " " + false);
                }
            } else {
                System.out.println(false + " " + false);
            }
        } else {
            System.out.println("data error");
        }
    }
}

class point {

    double x;
    double y;

    boolean flag;

    public point() {

    }

    public void fun(String a) {
        boolean flag1 = true;
        int number1 = 0;
        int number3 = 0;
        int number4 = 0;
        int number5 = 0;
        int number6 = 0;
        int number7 = 0;
        int number8 = 0;
        int number9 = 0;
        int fond = 0;
        for (int i = 0; i < a.length(); i++) {
            if (a.charAt(i) == ',') {
                number1++;
                fond = i;
            }
            if ((a.charAt(i) >= '0' && a.charAt(i) <= '9') || a.charAt(i) == ',' || a.charAt(i) == '.'
                    || a.charAt(i) == '-' || a.charAt(i) == '+') {
                number3++;
            }

        }
        for (int i = 0; i < fond; i++) {
            if (a.charAt(i) == '-') {
                number4++;
                if (i == 0 || a.charAt(i - 1) == ',') {

                } else {
                    flag1 = false;
                }}
            if (a.charAt(i) == '+') {
                number5++;
                if (i == 0 || a.charAt(i - 1) == ',') {

                } else {
                    flag1 = false;
                }
            }
            if (a.charAt(i) == '.') {
                number8++;
                if (i == 0 || i == fond - 1) {
                    flag1 = false;
                }
            }
        }
        for (int i = fond + 1; i < a.length(); i++) {
            if (a.charAt(i) == '-') {
                number6++;
                if (i == 0 || a.charAt(i - 1) == ',') {

                } else {
                    flag1 = false;
                }
            }
            if (a.charAt(i) == '+') {
                number7++;
                if (i == 0 || a.charAt(i - 1) == ',') {

                } else {
                    flag1 = false;
                }
            }
            if (a.charAt(i) == '.') {
                number9++;
                if (i == fond + 1 || i == a.length() - 1) {
                    flag1 = false;
                }
            }
        }
        if (number4 + number5 <= 1 && number6 + number7 <= 1 && flag1 == true && number4 <= 1 && number5 <= 1
                && number6 <= 1 && number7 <= 1 && number1 == 1 && number3 == a.length() && number9 <= 1
                && number8 <= 1) {
            flag = true;
            x = Double.parseDouble(a.substring(0, fond));
            y = Double.parseDouble(a.substring(fond + 1, a.length()));
        } else {
            flag = false;
        }
    }

}

本代码为题目集三7-2，此题因为时间问题和知识运用不够熟练，并没在pta联系中提交，有后余时间将其完成。本题考察点与线间的距离运算问题，本题目与数学结合，难度为输入数字正确进入相应判断运行公式中，正确输出，建立不同的数据类型，调用建立函数，进入计算运行，其他问题为情况不符合情况，判断问题的否定输出等等。本题出现多次Blog，多次看书，在网上查找学习资料，学习，了解，最后进行编程。

下面是我从网上寻找的降低圈复杂度的方法，在今后的学习或者在解决PTA题目时会学着慢慢的渗透和尝试降低圈复杂度的方法。

•Simplifying Conditional Expressions（简化条件表达式）

Decompose Conditional（分解条件式）

Consolidate Conditional Expression（合并条件式）

Consolidate Duplicate Conditional Fragments（合并重复的条件片断）

import java.util.Scanner;
public class Main{
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        System.out.println("outof the triangle");
    }
}

本代码为题目集三7-3，本题目考察三角形的计算系列问题，此题目建立多组函数。

• 采坑心得

1.在设计类时，圈复杂度较大，在今后我将学习如何将圈复杂度降低。

2.在交到pta上的时候我的代码出现了得分不满的问题，但是在其他编译器上可以进行编辑，是因为我考虑少了情况，没有多方面考虑，如题目集一的第四题，for的循环类型建立不足，导致正确结构无法全部输出，所以在日后我要考虑多种情况的发生

3.类与类之关系，以及怎样更好的减少类与类之间的关系，在设计代码时，我设计的两个类总是有很多的关联，子类继承父类的功能，这些关系我在解题时依然不清楚。

4.多道练习的训练，是我对数组建立的应用，字符串，循环大大熟练，更好的进行数组和字符串，循环的运用

if(a.length()<11) {
            System.out.print("null data");
            return;
        }
        if(a.matches("^[1]*$")) {
            System.out.print("null data");
            return;

switch(ch1) {
            case 1:
                    switch(ch2) {
                    case 1:System.out.printf("人类 战士");break;
                    case 2:System.out.printf("人类 法师");break;
                    case 3:System.out.printf("人类 射手");break;
                    default:System.out.printf("Wrong Format");
                    }break;
            case 2:
                    switch(ch2) {
                    case 1:System.out.printf("精灵 战士");break;
                    case 2:System.out.printf("精灵 法师");break;
                    case 3:System.out.printf("精灵 射手");break;
                    default:System.out.printf("Wrong Format");
                    }break;
            case 3:
                    switch(ch2) {
                    case 1:System.out.printf("兽人 战士");break;
                    case 2:System.out.printf("兽人 法师");break;
                    case 3:System.out.printf("兽人 射手");break;
                    default:System.out.printf("Wrong Format");
                    }break;
            case 4:
                    switch(ch2) {
                    case 1:System.out.printf("暗精灵 战士");break;
                    case 2:System.out.printf("暗精灵 法师");break;
                    case 3:System.out.printf("暗精灵 射手");break;
                    default:System.out.printf("Wrong Format");
                    }break;
            default:System.out.printf("Wrong Format");

• 改进建议

1.我的代码在写时会比较麻烦，就会浪费时间，在之后我会调整代码，较少时间浪费。

2.在一些代码的关键节点，我应该加上一些注释，方便之后的查阅和修改。

3.减少代码与代码的耦合性，一个类应该对自己需要耦合或者调用的类知道的越少越好，遵循迪米特原则。

4.自己对知识的运用不是太过与熟练，今后定会加强基础练习，完善知识，加强运用。

• 总结

1.通过三次的习题集，尤其是题目1（7-4）、题目集3（7-2）这两个题在关于类设计的时候，设计到的程序设计原则，实现同样的功能，类的设计却有好几种可能，怎样使类的设计更加的合理，能大大的提高我们代码的质量。

2.我应多在类方面下功夫，我认为类是可以很好的避免不同的错误。

3.部分框架的使用比c语言数组要简单，运用的更容易，可以帮我们减少很多错误，减少我们在修改时浪费的时间，在今后的设计中，自己要学习使用这些方便的集合框架的，使代码更加的简洁、方便，且实现功能。

4.希望老师能够给更多的时间来完成作业，题目的难度希望是逐渐加深，不是一个题目集中都是很难的题目。

5这三次的习题集，又进一步的提升了我的编程能力，初步形成了面向对象设计的思想，以及类与类之间的关系都得到了一定程度的掌握，这三次习题集的有一定的收获。