Java题目集1~3总结

1.前言：

　　 前三次题目集主要关于java语言的基本程序设计，知识点涉及从最基础的命名变量到对象和类，其中包括了选择结构，循环结构，数学函数，数组，字符和字符串以及方法的定义与调用，正则表达式的使用，还有一些其他的类的方法的使用等内容。题量适中，均能在规定时间内做完，但不一定能做全对。难度循序渐进，从第一次的基础题目到第三次的进阶题目，普遍基本思路不难，但是一开始敲击代码就会发现细节方面很难把握到位，尤其是有关于输入测试的部分尤为突出，明显很难考虑到每一个方面以至于无法拿到满分，总会有测试点过不了（并且由于大部分测试点没有提示，需要分析考虑的更加全面以及反复反反复复。。。的试错）。个人认为第三次题目最难，不但体现于输入方面，在整体计算中也有体现，涉及不少数学知识，无论是第二道题目的直线之前的关系还是第三道题的三角形有关计算都不简单，转化为代码后更能复杂，需要更多的时间来分析思考。题目量随难度成反比，但是每道题目都很又代表性，值得深入去思考和反复修改。特别是第三次作业，虽然只有三道题，但是每道题的难度都很大，且题目之间层层递进，每道题都建立在上道题的基础上而衍生出新的问题。对于初步学习Java的我来说很具有挑战性。

　　总的来说，Java又是我们新接触的编程语言，对Java语言的运用还有些许生疏，对语法的理解和java整体结构把握不够清晰以及有关方面的设计还不清晰，需要加强训练以求熟练能够更好的应用。

2.设计与分析：

 7-2 串口字符解析

import java.util.Scanner;

public class Main{
        public static void main(String[] args){
            String s;
            Scanner sc= new Scanner(System.in);
            s=sc.next();
            boolean flag=false;
            int count=0,i=0,num=1;
            if(s.length()<11) {
                System.out.print("null data");
                return;
            }
            for(i=0;i<s.length();i++){
                if(s.charAt(i)=='0'){
                    flag=true;
                    break;
                }
            }
            if(!flag){
                System.out.print("null data");
                return;
            }
            for(i=0;i<s.length()-10;i++){
                if(s.charAt(i)=='0'){
                    System.out.print(num+":");
                    num++;
                    if(s.charAt(i+10)=='1'){
                        count=0;
                        for(int j=i+1;j<=i+8;j++){
                            if(s.charAt(j)=='1'){
                                count++;
                            }
                        }
                        if(((count%2==0)&&(s.charAt(i+9)=='1'))||((count%2!=0)&&(s.charAt(i+9)=='0'))){
                            System.out.println(s.substring(i+1, i+9));
                        }
                        else{
                            System.out.println("parity check error");
                        }
                    }
                    else{
                        System.out.println("validate error");
                    }
                    i+=10;
                }
            }
    }
}

 本题难点主要体现在对RS232以及奇偶校验位应用的陌生，以及对模拟串口接收处理程序的陌生。

 代码分析与处理：

1.判断输入中的数据是否大于11位，若小于11位则数据中一定没有有效数据。

2.判断数据是否有"0"位。

3.开始找首次出现的"0"位，找到"0"后开始对他后面10位做处理判断。

4.先判断最后一位是不是结束1，再判断是否奇校验正确，最后通过两次判断结果来输出。

7-1 点线形系列1-计算两点之间的距离

import java.util.Scanner;

public class Main{
        public static void main(String[] args){
            Scanner sc=new Scanner(System.in);
            String point=sc.nextLine();
            String[] num =null;
            double x1,y1,x2,y2;
            if(point.length()<7){
                System.out.print("Wrong Format");
                return;
            }
            else{
                String[] data = point.split(" ");
                for(int i=0;i<data.length;i++){
                    num = data[i].split(",");
                    for(int j=0;j<num.length;j++){
                        if(!num[j].matches("^[+-]?(0|(0\\.\\d+)?|[1-9][0-9]*(\\.\\d+)?)$")){
                            System.out.print("Wrong Format");
                            return;
                        }
                        if(num[j].equals("0.0")){
                            System.out.print("Wrong Format");
                            return;
                        }
                    }
                }
                if(data.length!=2){
                    System.out.print("wrong number of points");
                    return;
                }
                num=data[0].split(",");
                x1=Double.valueOf(num[0]);
                y1=Double.valueOf(num[1]);
                num=data[1].split(",");
                x2=Double.valueOf(num[0]);
                y2=Double.valueOf(num[1]);
                if(x1==x2&&y1==y2){
                    System.out.print("Wrong Format");
                    return;
                }
                System.out.print(Math.sqrt((Math.pow((x1-x2),2)+Math.pow((y1-y2),2))));
            }
        }
    }

代码分析与处理：

1.通过判断输入的数据是否大于7位，若小于7位则数据中一定没有有效数据。

2.可以通过判断每一个字符的首位来判断是否符合"-"或者"+"同时判断下一位是否为数字（如为小数之后加上判断是否为小数点'.'，之后判断下一位是否为数字，以及之后无其他符号出现后结束判断），来确定输入数据是否符合正确的格式。

3.或者直接通过判断是否正确符合正则表达式，来判断是否符合正确需要的格式。

4.之后通过判断点的个数和两点重复等特殊情况来判断，最后得出结果。

 分析报告：

7-2 点线形系列2-线的计算

import java.util.Scanner;
public class Main{
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int x1, y1, x2, y2;
        int count=0,cnt=0;
        String point = sc.nextLine();
        String data[] = null;
        if (point.charAt(0) >= '1' && point.charAt(0) <= '5' && point.charAt(1) == ':') {
            for (int i=2;i<point.length();i++){
                if(point.charAt(i)==' '){
                    cnt++;
                }
                if(point.charAt(i)==','){
                    count++;
                }
            }
            if(count-1!=cnt){
                System.out.print("Wrong Format");
                return;
            }
            data = point.split(":|,| ");
            for (int i = 1; i < data.length; i++){
                if(data[i].equals("0.00")||data[i].equals("")){
                    System.out.print("Wrong Format");
                    return;
                }
                if (!data[i].matches("^[+-]?(0|(0\\.\\d+)?|[1-9][0-9]*(\\.\\d+)?)$")){
                    System.out.print("Wrong Format");
                    return;
                }
            }
        } else {
            System.out.print("Wrong Format");
            return;
        }
        switch(data[0]){
            case "1":
                Slope(data);
                break;
            case "2":
                Vertical(data);
                break;
            case "3":
                ISonline(data);
                break;
            case "4":
                ISparallel(data);
                break;
            default:
                ISnode(data);
                break;
        }
    }
    public static boolean ISsame(Double x1,Double y1,Double x2,Double y2){
        if(x1.equals(x2)&&y1.equals(y2)){
            return true;
        } else {
            return false;
        }
    }

    public static void Slope(String[] num) {
        if(num.length != 5) {
            System.out.print("wrong number of points");
            return;
        }
        Double[] arr = new Double[20];
        for (int i = 1; i < num.length; i++) {
            arr[i] = Double.valueOf(num[i]);
        }
        if(ISsame(arr[1],arr[2],arr[3],arr[4])){
            System.out.print("points coincide");
            return;
        }
        else if(arr[1].equals(arr[3])) {
            System.out.print("Slope does not exist");
            return;
        } else {
            double result = (arr[4] - arr[2]) / (arr[3] - arr[1]);
            System.out.print(result);
        }
    }

    public static void Vertical(String[] num){
        if(num.length != 7){
            System.out.print("wrong number of points");
            return;
        }
        Double[] arr = new Double[20];
        for (int i = 1; i < num.length; i++) {
            arr[i] = Double.valueOf(num[i]);
        }
        if(ISsame(arr[1],arr[2],arr[3],arr[4])||ISsame(arr[1],arr[2],arr[5],arr[6])||ISsame(arr[3],arr[4],arr[5],arr[6])){
            System.out.print("points coincide");
            return;
        }
        else{
            double a,b,c,result;
            a=arr[4]-arr[6];
            b=arr[5]-arr[3];
            c=(arr[4]+arr[6])*arr[3]-(arr[3]+arr[5])*arr[4];
            result=Math.abs((a*arr[1]+b*arr[2]+c)/Math.sqrt(a*a+b*b));
            System.out.print(result);
        }
    }
    public static void ISonline(String[] num){
        if(num.length != 7){
            System.out.print("wrong number of points");
            return;
        }
        Double[] arr = new Double[20];
        for (int i = 1; i < num.length; i++) {
            arr[i] = Double.valueOf(num[i]);
        }
        if(ISsame(arr[1],arr[2],arr[3],arr[4])||ISsame(arr[1],arr[2],arr[5],arr[6])||ISsame(arr[3],arr[4],arr[5],arr[6])){
            System.out.print("points coincide");
            return;
        }
        else{
            double a,b,c;
            boolean flag=false;
            a=arr[4]-arr[6];
            b=arr[5]-arr[3];
            c=arr[6]*arr[3]-arr[5]*arr[4];
            if((a*arr[1]+b*arr[2]+c)==0){
                System.out.print("true");
            }
            else{
                System.out.print("false");
            }
        }
    }

    public static void ISparallel(String[] num){
        if(num.length != 9){
            System.out.print("wrong number of points");
            return;
        }
        Double[] arr = new Double[20];
        for (int i = 1; i < num.length; i++) {
            arr[i] = Double.valueOf(num[i]);
        }
        if(ISsame(arr[1],arr[2],arr[3],arr[4])||ISsame(arr[1],arr[2],arr[5],arr[6])||ISsame(arr[1],arr[2],arr[7],arr[8])||ISsame(arr[3],arr[4],arr[5],arr[6])||ISsame(arr[3],arr[4],arr[7],arr[8])||ISsame(arr[5],arr[6],arr[7],arr[8])){
            System.out.print("points coincide");
            return;
        }
        else{
            double ax=0,ay=0,bx=0,by=0;
            ax  = arr[3]-arr[1];
            ay  = arr[4]-arr[2];
            bx  = arr[7]-arr[5];
            by  = arr[8]-arr[6];
            if(ax * by - bx * ay==0){
                System.out.print("true");
            }
            else{
                System.out.print("false");
            }
        }
    }

    public static void ISnode(String[] num){
        if(num.length != 9){
            System.out.print("wrong number of points");
            return;
        }
        double[] arr = new double[20];
        for (int i = 1; i < num.length; i++) {
            arr[i] = Double.valueOf(num[i]);
        }
        if(ISsame(arr[1],arr[2],arr[3],arr[4])||ISsame(arr[1],arr[2],arr[5],arr[6])||ISsame(arr[1],arr[2],arr[7],arr[8])||ISsame(arr[3],arr[4],arr[5],arr[6])||ISsame(arr[3],arr[4],arr[7],arr[8])||ISsame(arr[5],arr[6],arr[7],arr[8])){
            System.out.print("points coincide");
            return;
        }
        else{
            double ax=0,ay=0,bx=0,by=0;
            ax  = arr[3]-arr[1];
            ay  = arr[4]-arr[2];
            bx  = arr[7]-arr[5];
            by  = arr[8]-arr[6];
            if(ax * by - bx * ay==0){
                System.out.print("is parallel lines,have no intersection point");
                return;
            }
            else{
                double x,y;
/*              A = Y2 - Y1
                B = X1 - X2
                C = X2*Y1 - X1*Y2
               */
                double a1=arr[4]-arr[2];
                double b1=arr[1]-arr[3];
                double c1=arr[3]*arr[2]-arr[1]*arr[4];
                double a2=arr[8]-arr[6];
                double b2=arr[5]-arr[7];
                double c2=arr[7]*arr[6]-arr[5]*arr[8];
                x=(b2*c1-b1*c2)/(a2*b1-a1*b2);
                y=(a1*c2-a2*c1)/(a2*b1-a1*b2);
                double x1= Math.max(arr[1],arr[3]);
                double x2= Math.max(arr[5],arr[7]);
                double x3= Math.min(arr[1],arr[3]);
                double x4= Math.min(arr[5],arr[7]);
                System.out.print(x+","+y);
                if((x>x3||x>x4)&&(x<x1||x<x2)){
                    System.out.print(" true");
                }
                else{
                    System.out.print(" false");
                }
            }
        }
    }
}

代码分析与处理：

1.输入的判断，输入中有空格和字符","的出现，对输入判断不方便。

2.输入数据第一位必须是数字且为1-5，第二位必须为":"(可作为先行判断的条件）

3.输入的点的坐标必须和输入的第一位数字的对应情况对应。

4.两个点的坐标之间以空格分隔,每个点的x,y坐标以英文“,”分隔。

5.每个数字前"+","-"只能有一个,必须符合基本格式：选项+":"+坐标x+","+坐标y+" "+坐标x+","+坐标y。

6.定义一个字符串，将输入数据存入其中,同时对字符串中的","和空格数量进行对比,对所给数据进行字符串进行切割。

7.之后可对所给数据进行是否符合正则表达式判断，看其是否符合基本格式。

8.再运用switch语句，根据所读入的数字确定为何种情况，根据不同的情况判断输入数据的点数以及坐标是否重合，是否符合规定等等。

9.若为情况1则计算两点的斜率。

　　若为情况2则运用数学公式，通过所给点坐标计算出距离，并输出。

　　若为情况3则计算任意两个的斜率是否相等，若相等则输出true反之不相等则输出false。

　　若为情况4则计算前两个点所构成的直线的斜率是否与后面一点相等（通过向量法来判断），若相等则输出true反之不相等则输出false。

　　若为情况5则运用数学公式计算两直线交点坐标，并通过交点坐标的x，与其他四个点对比得出是否在两线段之内。

类图：

分析报告：

　　

7-3 点线形系列3-三角形的计算

import java.text.DecimalFormat;
import java.util.Arrays;
import java.util.Scanner;
public class Main{
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int x1, y1, x2, y2;
        int count = 0, cnt = 0;
        String point = sc.nextLine();
        String data[] = null;
        if (point.charAt(0) >= '1' && point.charAt(0) <= '5' && point.charAt(1) == ':') {
            for (int i = 2; i < point.length(); i++) {
                if (point.charAt(i) == ' ') {
                    cnt++;
                }
                if (point.charAt(i) == ',') {
                    count++;
                }
            }
            if (count - 1 != cnt) {
                System.out.print("Wrong Format");
                return;
            }
            data = point.split(":|,| ");
            for (int i = 1; i < data.length; i++) {
                if (!data[i].matches("^[+-]?(0|(0\\.\\d+)?|[1-9][0-9]*(\\.\\d+)?)$")) {
                    System.out.print("Wrong Format");
                    return;
                }
            }
        } else {
            System.out.print("Wrong Format");
            return;
        }
        switch (data[0]) {
            case "1":
                Isequilateral_Isosceles(data);
                break;
            case "2":
                Calculate(data);
                break;
            case "3":
                Istriangletype(data);
                break;
            case "4":
                Piontnumber(data);
                break;
            default:
                Isontriangle(data);
                break;
        }
    }

    public static boolean ISsame(Double x1, Double y1, Double x2, Double y2) {
        if (x1.equals(x2) && y1.equals(y2)) {
            return true;
        } else {
            return false;
        }
    }

    public static boolean IStriangle(double x1,double y1,double x2,double y2,double x3,double y3) {
        double Side_Length1 = Math.sqrt(Math.pow(x2 - x1, 2) + Math.pow(y2 - y1, 2));
        double Side_Length2 = Math.sqrt(Math.pow(x3 - x1, 2) + Math.pow(y3 - y1, 2));
        double Side_Length3 = Math.sqrt(Math.pow(x3 - x2, 2) + Math.pow(y3 - y2, 2));
        if ((Side_Length1 + Side_Length2 > Side_Length3) && (Side_Length2 + Side_Length3 > Side_Length1) && (Side_Length1 + Side_Length3 > Side_Length2)) {
            return true;
        } else {
            return false;
        }
    }

    public static void Isequilateral_Isosceles(String[] num) {
        if (num.length != 7) {
            System.out.print("wrong number of points");
            return;
        }
        Double[] arr = new Double[20];
        for (int i = 1; i < num.length; i++) {
            arr[i] = Double.valueOf(num[i]);
        }
        if (!IStriangle(arr[1],arr[2],arr[3],arr[4],arr[5],arr[6])) {
            System.out.print("data error");
            return;
        } else {
            double x1 = arr[1], y1 = arr[2];
            double x2 = arr[3], y2 = arr[4];
            double x3 = arr[5], y3 = arr[6];
            double Side_Length1 = Math.sqrt(Math.pow(x2 - x1, 2) + Math.pow(y2 - y1, 2));
            double Side_Length2 = Math.sqrt(Math.pow(x3 - x1, 2) + Math.pow(y3 - y1, 2));
            double Side_Length3 = Math.sqrt(Math.pow(x3 - x2, 2) + Math.pow(y3 - y2, 2));
            if ((Side_Length1 == Side_Length2) || (Side_Length2 == Side_Length3) || (Side_Length1 == Side_Length3)) {
                System.out.print("true");
                if ((Side_Length1 == Side_Length2) && (Side_Length2 == Side_Length3)) {
                    System.out.print(" true");
                } else {
                    System.out.print(" false");
                }
                return;
            } else {
                System.out.print("false false");
                return;
            }
        }
    }

    public static void Calculate(String[] num) {
        if (num.length != 7) {
            System.out.print("wrong number of points");
            return;
        }
        Double[] arr = new Double[20];
        for (int i = 1; i < num.length; i++) {
            arr[i] = Double.valueOf(num[i]);
        }
        if (!IStriangle(arr[1],arr[2],arr[3],arr[4],arr[5],arr[6])) {
            System.out.print("data error");
            return;
        } else {
            double x1 = arr[1], y1 = arr[2];
            double x2 = arr[3], y2 = arr[4];
            double x3 = arr[5], y3 = arr[6];
            double Side_Length1 = Math.sqrt(Math.pow(x2 - x1, 2) + Math.pow(y2 - y1, 2));
            double Side_Length2 = Math.sqrt(Math.pow(x3 - x1, 2) + Math.pow(y3 - y1, 2));
            double Side_Length3 = Math.sqrt(Math.pow(x3 - x2, 2) + Math.pow(y3 - y2, 2));
            double circumference = Side_Length1 + Side_Length2 + Side_Length3;
            double p = 0.5 * circumference;
            double area = Math.sqrt(p * (p - Side_Length1) * (p - Side_Length2) * (p - Side_Length3));
            double gx = (arr[1] + arr[3] + arr[5]) / 3;
            double gy = (arr[2] + arr[4] + arr[6]) / 3;
            System.out.print(new DecimalFormat("0.0#####").format(circumference) + " ");
            System.out.print(new DecimalFormat("0.0#####").format(area) + " ");
            System.out.print(new DecimalFormat("0.0#####").format(gx));
            System.out.print("," + new DecimalFormat("0.0#####").format(gy));
        }
    }

    public static void Istriangletype(String[] num) {
        if (num.length != 7) {
            System.out.print("wrong number of points");
            return;
        }
        Double[] arr = new Double[20];
        for (int i = 1; i < num.length; i++) {
            arr[i] = Double.valueOf(num[i]);
        }
        if (!IStriangle(arr[1],arr[2],arr[3],arr[4],arr[5],arr[6])) {
            System.out.print("data error");
            return;
        } else {
            double x1 = arr[1], y1 = arr[2];
            double x2 = arr[3], y2 = arr[4];
            double x3 = arr[5], y3 = arr[6];
            double Side_Length1 = Math.sqrt(Math.pow(x2 - x1, 2) + Math.pow(y2 - y1, 2));
            double Side_Length2 = Math.sqrt(Math.pow(x3 - x1, 2) + Math.pow(y3 - y1, 2));
            double Side_Length3 = Math.sqrt(Math.pow(x3 - x2, 2) + Math.pow(y3 - y2, 2));
            double[] line = {Side_Length1, Side_Length2, Side_Length3};
            Arrays.sort(line);
            if (Math.pow(line[2], 2) < (Math.pow(line[1], 2) + Math.pow(line[0], 2))) {
                System.out.print("false false true");
                return;
            } else if (Math.pow(line[2], 2) - Math.pow(line[1], 2) - Math.pow(line[0], 2) < 1e-6) {
                System.out.print("false true false");
                return;
            } else if (Math.pow(line[2], 2) > (Math.pow(line[1], 2) + Math.pow(line[0], 2))) {
                System.out.print("true false false");
                return;
            }
        }
    }

    public static void Piontnumber(String[] num) {
        if (num.length != 11) {
            System.out.print("wrong number of points");
            return;
        }
        Double[] arr = new Double[20];
        for (int i = 1; i < num.length; i++) {
            arr[i] = Double.valueOf(num[i]);
        }
        if (ISsame(arr[1], arr[2], arr[3], arr[4])) {
            System.out.print("points coincide");
            return;
        }
        if (!IStriangle(arr[5],arr[6],arr[7],arr[8],arr[9],arr[10])) {
            System.out.print("data error");
            return;
        } else {
            double a1 = arr[4] - arr[2];
            double b1 = arr[1] - arr[3];
            double c1 = arr[3] * arr[2] - arr[1] * arr[4];
            if (((a1 * arr[5] + b1 * arr[6] + c1 == 0) && (a1 * arr[7] + b1 * arr[8] + c1 == 0)) || ((a1 * arr[5] + b1 * arr[6] + c1 == 0) && (a1 * arr[9] + b1 * arr[10] + c1 == 0)) || ((a1 * arr[7] + b1 * arr[8] + c1 == 0) && (a1 * arr[9] + b1 * arr[10] + c1 == 0))) {
                System.out.print("The point is on the edge of the triangle");
                return;
            }
            double[] point1 = point(arr[5], arr[6], arr[7], arr[8], arr[1], arr[2], arr[3], arr[4]);
            double[] point2 = point(arr[7], arr[8], arr[9], arr[10], arr[1], arr[2], arr[3], arr[4]);
            double[] point3 = point(arr[5], arr[6], arr[9], arr[10], arr[1], arr[2], arr[3], arr[4]);
            if((point1[0]==65536.0)&&(point2[0] == 65536.0)&&(point3[0] ==65536.0)){
                System.out.print("0");
                return;
            }
            if (((point1[0] == point2[0]) && (point1[1] == point2[1]) && (point3[0]==65536.0)) || ((point1[0] == point3[0]) && (point1[1] == point3[1]) && (point2[0] == 65536.0)) || ((point2[0] == point3[0]) && (point2[1] == point3[1]) && (point1[0] ==65536.0))){
               System.out.print("1");
                return;
            } else {
                double area=area(arr[5],arr[6],arr[7],arr[8],arr[9],arr[10]);
                double area1=0;
                if(point3[0]==65536.0){
                    area1=area(arr[7],arr[8] ,point1[0] ,point1[1] ,point2[0] ,point2[1]);
                }
                else if(point2[0]==65536.0){
                    area1=area(arr[5],arr[6] ,point1[0] ,point1[1] ,point3[0] ,point3[1]);
                }
                else if(point1[0]==65536.0){
                    area1=area(arr[9],arr[10] ,point2[0] ,point2[1] ,point3[0] ,point3[1]);
                }
                else if((point1[0] == point2[0])&&(point1[1]==point2[1])){
                    area1=area(point1[0],point1[1] ,point3[0] ,point3[1] ,arr[5] ,arr[6]);
                }
                else if((point1[0] == point3[0])&&(point1[1]==point3[1])){
                    area1=area(point1[0],point1[1] ,point2[0] ,point2[1] ,arr[7] ,arr[8]);
                }
                else if((point2[0] == point3[0])&&(point2[1]==point3[1])){
                     area1=area(point2[0],point2[1] ,point1[0] ,point1[1] ,arr[5] ,arr[6]);
                }
                double area2=area-area1;
                if(area2<area1){
                    double temp = area1;
                    area1 = area2;
                    area2 = temp;
                }
                System.out.print("2 "+new DecimalFormat("0.0#####").format(area1) +" "+new DecimalFormat("0.0#####").format(area2));
                return;
            }
        }
    }

    public static double[] point(double x1, double y1, double x2, double y2, double ax1, double ay1, double ax2, double ay2) {
        double[] num = {65536.0,65536.0};
        double A = ay2 - ay1;
        double B = ax1 - ax2;
        double C = ax2 * ay1 - ax1 * ay2;
        double a = y2 - y1;
        double b = x1 - x2;
        double c = x2 * y1 - x1 * y2;
        double ax  = ax2-ax1;
        double ay  = ay2-ay1;
        double bx  = x2-x1;
        double by  = y2-y1;
        if(ax * by - bx * ay==0){
            num[0] = 65536.0;
            num[1] =65536.0;
            return num;
        }
        if (A == 0) {
            if (a == 0) {
                num[0] = 65536.0;
                num[1] =65536.0;
                return num;
            } else if (b == 0) {
                if ((ay1 <= y1 && ay1 >= y2) || (ay1 <= y2 && ay1 >= y1)) {
                    num[0] = ax1;
                    num[1] = ay1;
                }
            } else {
                double px = (b * ay1 + c) / (-a);
                if ((px <= x1 && px >= x2) || (px >= x1 && px <= x2)) {
                    num[0] = px;
                    num[1] = ay1;
                }
            }
        }
        if (B == 0) {
            if (a == 0) {
                if ((ax1 <= x1 && ax1 >= x2) || (ax1 >= x1 && ax1 <= x2)) {
                    num[0] = ax1;
                    num[1] = y1;
                }
            } else if (b == 0) {
                num[0] = 65536.0;
                num[1] =65536.0;
                return num;
            } else {
                double py = (a * ax1 + c) / (-b);
                if ((py <= y1 && py >= y2) || (py >= y1 && py <= y2)) {
                    num[0] = ax1;
                    num[1] = py;
                }
            }
        } else {
            if (a == 0) {
                double px = (B * y1 + C) / (-A);
                if ((px <= x1 && px >= x2) || (px >= x1 && px <= x2)) {
                    num[0] = px;
                    num[1] = y1;
                }
            } else if (b == 0) {
                double py = (A * x1 + C) / (-B);
                if ((py <= y1 && py >= y2) || (py >= y1 && py <= y2)) {
                    num[0] = x1;
                    num[1] = py;
                }
            } else {
                double px = (b * C - B * c) / (a * B - A * b);
                if ((px <= x1 && px >= x2) || (px >= x1 && px <= x2)) {
                    num[0] = px;
                    num[1] = (A * px + C) / (-B);
                }
            }
        }
        return num;
    }

    public static double area(double x1,double y1,double x2,double y2,double x3,double y3){
        double Side_Length1 = Math.sqrt(Math.pow(x2 - x1, 2) + Math.pow(y2 - y1, 2));
        double Side_Length2 = Math.sqrt(Math.pow(x3 - x1, 2) + Math.pow(y3 - y1, 2));
        double Side_Length3 = Math.sqrt(Math.pow(x3 - x2, 2) + Math.pow(y3 - y2, 2));
        double circumference = Side_Length1 + Side_Length2 + Side_Length3;
        double p = 0.5 * circumference;
        double area = Math.sqrt(p * (p - Side_Length1) * (p - Side_Length2) * (p - Side_Length3));
        return area;
    }

    public static void Isontriangle (String[]num){
        if (num.length != 9) {
            System.out.print("wrong number of points");
            return;
        }
        Double[] arr = new Double[20];
        for (int i = 1; i < num.length; i++) {
            arr[i] = Double.valueOf(num[i]);
        }
        if (!IStriangle(arr[3],arr[4],arr[5],arr[6],arr[7],arr[8])) {
            System.out.print("data error");
            return;
        }
        int count=0;
        double a1=arr[6]-arr[4];
        double b1=arr[3]-arr[5];
        double c1=arr[5]*arr[4]-arr[3]*arr[6];
        double a2=arr[8]-arr[6];
        double b2=arr[5]-arr[7];
        double c2=arr[7]*arr[6]-arr[5]*arr[8];
        double a3=arr[8]-arr[4];
        double b3=arr[3]-arr[7];
        double c3=arr[7]*arr[4]-arr[3]*arr[8];
        if((a1*arr[1]+b1*arr[2]+c1==0)||(a2*arr[1]+b2*arr[2]+c2==0)||(a3*arr[1]+b3*arr[2]+c3==0)){
            System.out.print("on the triangle");
            return;
        }
        count+=numpoint(arr[3],arr[4],arr[5],arr[6],arr[1],arr[2]);
        count+=numpoint(arr[5],arr[6],arr[7],arr[8],arr[1],arr[2]);
        count+=numpoint(arr[3],arr[4],arr[7],arr[8],arr[1],arr[2]);
        if(count%2==0){
            System.out.print("outof the triangle");
            return;
        }
        else{
            System.out.print("in the triangle");
            return;
        }
    }

    public static int numpoint(double x1,double y1,double x2,double y2,double x,double y){
        int count=0;
        double a= y2 - y1;
        double b= x1 - x2;
        double c= x2*y1-x1*y2;
        if(a==0){
            return count;
        }
        if(b==0){
            if(x>x1){
                count++;
            }
        }
        else{
            double px=(b*y+c)/(-a);
            if((px<x1&&px>x2&&px<x)||(px>x1&&px<x2&&px<x)){
                count++;
            }
        }
        return count;
    }
}

代码分析与处理：

1.输入的判断，输入中有空格和字符","的出现，对输入判断不方便。

2.输入数据第一位必须是数字且为1-5，第二位必须为":"(可作为先行判断的条件）

3.输入的点的坐标必须和输入的第一位数字的对应情况对应。

4.两个点的坐标之间以空格分隔,每个点的x,y坐标以英文“,”分隔。

5.每个数字前"+","-"只能有一个,必须符合基本格式：选项+":"+坐标x+","+坐标y+" "+坐标x+","+坐标y。

6.定义一个字符串，将输入数据存入其中,同时对字符串中的","和空格数量进行对比,对所给数据进行字符串进行切割。

7.之后可对所给数据进行是否符合正则表达式判断，看其是否符合基本格式。

8.再运用switch语句，根据所读入的数字确定为何种情况，根据不同的情况判断输入数据的点数以及坐标是否重合，判断是否点的数量符合要求，输入的数据是否能够构成正常三角形等等。

9.若为情况1则断是否是等腰三角形、等边三角形，运用三边之间的关系。

若为情况2则运用数学公式，通过所给点坐标计算出周长、面积、重心坐标。

若为情况3则运用数学公式，通过三边的关系计算出是钝角、直角还是锐角三角形。

若为情况4则计算两个点所在的直线与三个点所构成的三角形相交的交点数量，如果交点有两个，则按面积大小依次输出三角形被直线分割成两部分的面积，否则直接输出交点的个数。若直线与三角形一条线重合，输出"The point is on the edge of the triangle"。

若为情况5则使用射线法，水平做一条射线计算出与与三角形交点数量，在其左端的个数，判断是否奇数以此判断是否在后三个点所构成的三角形的内部。

类图：

 分析报告：

采坑心得： 

　　1.在7-2 串口字符解析中，此题在理解题意方面，要求准确看懂题目意思，急于下手开始敲代码反而会造成更多的错误判断，以及题目中是过滤后的数据长度大于11，而不是输入的数据长度大于11,同时注意数组中元素下标可能出现的越界问题(设置好相关限制条件)。

　　2.在7-1 点线形系列1-计算两点之间的距离中，有几个测试点很坑的例子如："0.0"和"0."等等，均该输出结果wrong format。需要多加以考虑和判断来解决。

　　3.在7-2 点线形系列2-线的计算中，在进行相关的判断的时候要考虑斜率是否存在等问题，以及一些特殊情况输入等问题如"0.00"等，关于点是否在两线段内的判断：将交点的X坐标大于两线段的各点的最小值并且小于最大值，满足任意所述条件即可判断在线段内。

　　4.在7-3 点线形系列3-三角形的计算中，在输出数据方面可以使用DecimalFormat()方法来实现符合要求的数据格式；对于直角三角形的判断存在一个精度损失问题，通过约定最长边与各边之和的差小于1e-6来加以判断；计算输出前两个点所在的直线与三个点所构成的三角形相交的交点数量时，记得输出点数为"0"的情况；计算三角形的面积方法可以通过海伦公式进行计算减少数据计算量和精度损失；采用射线法判断是否在三角形内部，水平做直线寻找规定一边与三角形的交点的数量，根据个数判断是否在内部。（寻找合适的数学方法对于做题判断会有很大的帮助）。

改进建议：

　　由SourceMonitor以及PowerDesigner软件测评结果可以看到，上述几段程序的复杂度都高(并且还逐渐递增的趋势)，且都在主类中完成。这是段效率不高的代码，究其原因，是因为if语句过多，导致程序运行的过于拖沓后，以及一些判断过于冗杂。其实想处理的更为简洁，可以使用类的形式，将数据计算处理在一个计算类中，判断条件写在判断类中，结果输出写在一个输出类中，这样可以将题目处理的更有可读性。此次对于问题没有去探寻简便的解决方法，只是单纯地完成题目要求，导致每次都错过构造类的方法，使得代码又长又繁杂，不仅写的过程中容易出错，修改更是麻烦。所以应该只是做题，更应该思考，写代码前多想想自己的方法和思考构建类的结构及方法，而不是一个又一个小功能方法填充堆积而成。弥补类设计的缺陷，学会灵活运用类与类之间的多种关系，使代码简洁清晰。 直接判断解决完成，会使得题目复杂度较高，并且对于一些BUG修改和测试比较难以发现和修改，如果不去创建新的类，单单在main里一路写下来，代码将又长又复杂。不仅仅将目光放在实现结果上，而是同时关注代码的总体结构，结构清晰分工明确，实现代码也就又快又准。

总结：

　　首先在第一阶段的学习中，通过循序渐进的方式从开始从借助c语言的知识来认识Java，再到正式的了解面向对象的java设计，在这过程中对于类的运用和字符串以及数组等级基本类型的运用还需加强，尤其是一些基本语法。以及明白了面向过程范式聚焦于方法的设计，它将数据与方法结合在对象中。在许多Java方法要求使用对象作为参数，下一阶段学习任务也包括学会使用ava能将数据类型合并或包装到一个对象中。平时也要培养我们解决程序设计错误的能力，要学会去看给出的错误提示，学会总结，这样不仅能够避免也能更加掌握所学。在这几次作业的练习中，我也发现自身对于Java的了解不够深刻，同时代码的书写过程也需加强，很多题目的总体代码都存在重复性过高，可读性不强等问题。对类和对象的创建应用和方法的运用还需加强，对整体的题目程序涉及方面还需加强，有很多地方可以简化运算和代码。

　　需要进一步学习研究的部分：自己的编码思路还是按照面向过程思想来，没有把所学的面向对象思维应用到实际编码中，以及对java的一些知识了解不够深刻，停留在表面，实际还是沿用面向过程的思维，企图闭门造车，还需要加强对面向对象程序设计的学习。

　　改进建议及意见：

　　希望PTA的测试点给出简短说明，很多题目在提交时几乎“一碧千里”，但基本没几个测试点有相关说明，导致代码改错过程中不知道自己错在哪里，需要反复测试提交，不断更改代码，浪费很多时间。如有些模糊不清的输入判断如果增加一些提示将会更好。同时对于整体题目的难度，也可以增添一些循序渐进的过程。