一、作業總結

　　這幾次的PTA作業主要考察我們對Java語言中的字串的輸入和輸出、轉換、有關它們的方法的運用和相關的一些運算，還有我們對題目需求的瞭解和書寫程式碼的規範；其次還有強化我們對“類”的使用；當然還有我們對一些常見演算法的瞭解。

　　作業的題量還是與它的難度大概成反比，但就結果而言，三次的PTA作業難度逐漸增高，第一次作業最多但是比較簡單，第二次則是中規中矩，而第三次就是比較難了。在這裡的難其實很大一部分是因為在提交後即使知道自己的測試點錯了但是卻不知道測試點是什麼，這也就間接地提高了題目的難度。其次是題目要求的問題有些是我沒有見過和聽過的，以至於一見到它就不知道從何處下手，也不知道該用什麼演算法，在網上又找不到可以借鑑的方法（找到了也有些也是看不懂）。還有就是對一些方法的不熟也是一個痛點，翻書要時間，而且因為不知道寫方法而自己去寫程式碼去實現自己想要的功能也是有難度和要時間的。下面分別對一些作業做個簡要分析。

二、作業分析

1、串列埠字元解析（題目集2的7-2）

題目如下：

RS232是串列埠常用的通訊協議，在非同步通訊模式下，串列埠可以一次傳送5~8位資料，收發雙方之間沒有資料傳送時線路維持高電平，相當於接收方持續收到資料“1”（稱為空閒位），傳送方有資料傳送時，會在有效資料（5~8位，具體位數由通訊雙方提前設定）前加上1位起始位“0”，在有效資料之後加上1位可選的奇偶校驗位和1位結束位“1”。請編寫程式，模擬串列埠接收處理程式，注：假定有效資料是8位，奇偶校驗位採用奇校驗。

輸入格式:

由0、1組成的二進位制資料流。例如：11110111010111111001001101111111011111111101111

輸出格式:

過濾掉空閒、起始、結束以及奇偶校驗位之後的資料，資料之前加上序號和英文冒號。
如有多個數據，每個資料單獨一行顯示。
若資料不足11位或者輸入資料全1沒有起始位，則輸出"null data"，
若某個資料的結束符不為1，則輸出“validate error”。
若某個資料奇偶校驗錯誤，則輸出“parity check error”。
若資料結束符和奇偶校驗均不合格，輸出“validate error”。
如：11011或11111111111111111。
例如：
1:11101011
2:01001101
3:validate error

　　這道題給我們介紹了串列埠常用的通訊協議——RS232，並以此為題基礎，讓我們編寫程式，模擬串列埠接收處理程式，並且為了簡單，題目告訴我們輸入格式為由0、1組成的二進位制資料流。例如：11110111010111111001001101111111011111111101111，並且假定有效資料是8位，奇偶校驗位採用奇校驗。首先我們看到這麼長的資料流，應該不會去用“int”去輸入，所以我們應該可以從它要檢測每一個“0”和“1”和長度想到應該用“String”建立字串，並且再用“toCharArray()”這個方法來將它轉換成字元陣列，這樣才能更好去檢測資料。

Scanner in=new Scanner (System.in); 
        String str=in.nextLine();
        char [] num=str.toCharArray();

之後就是對輸入的資料進行分析和檢測，這裡只需要用for迴圈來檢查資料是否合法；還有進行資料流的輸出，程式碼如下：

 {
        Scanner in=new Scanner (System.in); 
        String str=in.nextLine();
        char [] num=str.toCharArray();
        int n=num.length;
        int ln=n/11+1;
        int[] zero=new int [ln];
        for(int i=0;i<ln;i++) {
            zero[i]=-1;
        }
        if(n<11) {
            System.out.println("null data");
        }
        else {
            int flag=0;
            for(int i=0;i<n;i++) {
                if(num[i]=='0') {
                    flag=1;
                    break;
                }
                else {
                    flag=0;
                }
            }
            if(flag==0) {
                System.out.println("null data");
            }
            else {
                int z=0;
                int a=0;
                while(a<n) {
                    if(num[a]=='0') {
                        flag=1;
                        zero[z]=a;
                        z++;
                        a=a+11;
                    }
                    else {
                        a++;
                    }
                }
                int m=0;
                for(int i=0;i<zero.length;i++) {
                    if(zero[i]!=-1) {
                        m++;
                    }
                }
                for (int i=0;i<m;i++ ) {
                    int time=i;
                    int jy=zero[i]+9;
                    int js=zero[i]+10;
                    int js2=js+11;
                    int jyy=0;
                    if(js<n) {
                        for(int j=1;j<=9;j++) {
                            if(num[zero[i]+j]=='1') {
                                jyy++;
                            }
                        }
                        time++;
                        if(jyy%2==1) {
                            if(num[js]=='0') {
                                System.out.print(time+":validate error");
                            }
                            else {
                                System.out.print(time+":");
                                for(int j=1;j<=8;j++) {
                                    System.out.print(num[zero[i]+j]);
                                }
                            }
                        }
                        else {
                            if(num[js]=='1') {
                                System.out.print(time+":parity check error");
                            }
                            else {
                                System.out.print(time+":validate error");
                            }
                        }
                        if(js2<n) {
                            System.out.println();
                        }
                    }
                    else {
                        break;
                    }
                }
            }
                
        }
    }

踩坑心得：這題要注意的是，題目中的奇偶校驗是用前面的合法的資料相加再加上資料倒數第二位的奇偶校驗來判斷資料是否合格並輸出，不然過不了樣例6：

輸入樣例6:

兩組資料，資料之間無空閒位。例如：

1110000000001100111000001

輸出樣例6:

在這裡給出相應的輸出。例如：

1:00000000
2:01110000

如果只是檢驗它的奇偶校驗為，那麼輸出的應該是：

1:parity check error
2:parity check error

　　改進建議：程式碼可以適當的簡潔一些，判斷資料是否合格可以定義不同的方法來實現，這樣應該會好一些。

二、點線形系列1-計算兩點之間的距離 （題目集3的7-1）

題目如下：輸入連個點的座標，計算兩點之間的距離。

輸入格式:

4個double型別的實數，兩個點的x，y座標，依次是x1、y1、x2、y2，兩個點的座標之間以空格分隔，每個點的x,y座標以英文“,”分隔。例如：0,0 1,1或0.1,-0.3 +3.5,15.6。
若輸入格式非法，輸出"Wrong Format"。
若輸入格式合法但座標點的數量超過兩個，輸出“wrong number of points”。

　　這題的題目要求很簡單，就是我們平常要算的兩點之間的距離，雖說題目一目瞭然，但是對輸入的資料要有很高的要求，只要輸入的資料不符合座標的形式，那就要程式報“"Wrong Format”，而且輸入正確後也要注意座標點的數量，超過了要求就會輸出“wrong number of points”。在這裡因為輸入的資料中存在空格和逗號等字元，所以我們輸入的時候也要選擇字串輸入。再然後就是對資料的校驗——是否有空格，逗號，小數點，加號和減號（而且不能同一個數裡出現兩個）的字元出現，接著好要注意空格和逗號的數量關係和位置關係，之後還要確定小數點後有沒有數、整數位有沒有出現只有兩個零的情況等等，做好以上檢驗後就開始計算，我們可以用“split(" ")”這個方法來將我們輸入的陣列進行字串按照空格分成兩個座標，再進行兩次“split(",")”來獲得兩個座標點x和y。之後再用“Double.parseDouble”來講字元轉換成double型別的x和y，最後再通過兩點之間的距離公式(√（x1-x2）²+(y1-y2)²)來計算距離。程式碼如下：

校驗程式碼：

import java.util.Scanner;

public class Main 
{
    public static void main(String[] args) 
    {
       Scanner in = new Scanner(System.in);
       String Point = in.nextLine();
       char[] point = Point.toCharArray();
       int flag=1;
       if(point.length<7) {
           flag=0;
       }
       else {
           flag=judge(point);
           if(flag==1) {
               for(int i=0;i<point.length-1;i++) {
                   if(point[i]=='+'||point[i]=='-') {
                       if(point[i+1]<'0'||point[i+1]>'9') {
                           flag=0;
                           break;
                       }
                   }
                   else if((point[i]<'0'||point[i]>'9')&&point[i]!=' '&&point[i]!=','&&point[i]!='.') {
                       flag=0;
                       break;
                   }
                   else {
                       continue;
                   }
                   if(flag==0) {
                       break;
                   }
               }
           }
           flag= judge1(point);
       }
       if(flag==1) {
           int dou=0;
           for(int i=0;i<point.length;i++) {
               if(point[i]==',') {
                   dou++;
               }
           }
           if(dou>2) {
               System.out.print("wrong number of points");
           }
           else if(dou==2) {
               calculate(Point);
           }
           else {
               System.out.print("Wrong Format");
           }
       }
       else {
           System.out.print("Wrong Format");
       }
    }
private static int judge1(char[] point) {
        
        int flag=1;
        for(int i=1;i<point.length-1;i++) {
            if(point[i]=='.') {
                if(point[i+1]==' '||point[i+1]==',') {
                    if(point[i-1]>='0'&&point[i-1]<='9') {
                        flag=0;
                        break;
                    }
                }
                else if(point[i-1]==' '||point[i-1]==',') {
                    if(point[i+1]>='0'&&point[i+1]<='9') {
                        flag=0;
                        break;
                    }
                }    
            }
        }
        if(flag==1) {
            for(int i=1;i<point.length-1;i++) {
                if(point[i]=='+'||point[i]=='-'||point[i]=='*'||point[i]=='/') {
                    if(point[i+1]>='0'&&point[i+1]<='9'&&point[i-1]>='0'&&point[i-1]<='9') {
                        flag=0;
                    }
                }
            }
        }
        for(int i=2;i<point.length;i++) {
            if(point[i]=='.'&&point[i-1]=='0'&point[i-2]=='0') {
                flag=0;
                break;
            }
        }
        return flag;
    } 

    private static int judge(char[] point) {
        int flag=1;
        int k=0;
        int d=0;
        int n=0;
        int [][]num=new int[2][];
         for(int i=0;i<point.length;i++) {
             if(point[i]==' ') {
                 k++;
             }
             else if(point[i]==','){
                 d++;
             }
             else {
                n++; 
             } 
         }
         if(point[0]==' '||point[0]==','||k>n||d>n||k+d>n||d-k!=1||point[point.length-1]<'0'||point[point.length-1]>'9') {
             flag=0;
         }
         else {
             int k1=0;
             int d1=0;
             num[0]=new int[k];
             num[1]=new int[d];
             for(int i=0;i<point.length;i++) {
                 if(point[i]==' ') {
                     num[0][k1]=i;
                     k1++;
                 }
                 else if(point[i]==','){
                    num[1][d1]=i;
                    d1++;
                 }
             }
             int j=0;
             while(j<k1) {
                 
                 if(Math.abs((num[1][j]+num[1][j+1])/2-num[0][j])!=1&&Math.abs((num[1][j]+num[1][j+1])/2-num[0][j])!=0) {
                     flag=0;
                     break;
                 }
                 j++;
             }
         }
        
        return flag;
    }
}

 計算程式碼：

private static void calculate(String Point) {
        String [] p=Point.split(" ");
        String P1=p[0];
        String P2=p[1];
        String [] xy1=P1.split(",");
        String [] xy2=P2.split(",");
        double x1=Double.parseDouble(xy1[0]);
        double y1=Double.parseDouble(xy1[1]);
        double x2=Double.parseDouble(xy2[0]);
        double y2=Double.parseDouble(xy2[1]);
        double L=Math.sqrt(Math.pow((x1-x2),2)+Math.pow((y1-y2),2));
        System.out.print(L);
        
    }

　　踩坑心得：比較一下本題的校驗程式碼和計算程式碼，我可以發現其實這道題的難點是在於資料的校驗上，寫這道題要考慮很多種輸入錯誤的格式，稍微不注意就會漏掉一些測試點，這也就是本題的唯一的難點。然後就是要記得並且不能寫錯。

　　改進建議：因為我自己這道題並沒有過全部的測試點，所以還是建議自己重新再檢查一遍自己校驗的程式碼。然後對程式碼的建議就是把校驗程式碼裡的一些類似的檢驗情況整合在一起，也可以運用多個方法來進行檢驗，這樣才能讓程式碼看上去更加明瞭。

三、點線形系列2-線的計算（題目集3的7-2）

題目如下：

使用者輸入一組選項和資料，進行與直線有關的計算。選項包括：
1：輸入兩點座標，計算斜率，若線條垂直於X軸，輸出"Slope does not exist"。
2：輸入三個點座標，輸出第一個點與另外兩點連線的垂直距離。
3：輸入三個點座標，判斷三個點是否在一條線上，輸出true或者false。
4：輸入四個點座標，判斷前兩個點所構成的直線與後兩點構成的直線是否平行，輸出true或者false.
5：輸入四個點座標，計算輸出前兩個點所構成的直線與後兩點構成的直線的交點座標，x、y座標之間以英文分隔","，並輸出交叉點是否在兩條線段之內（不含四個端點）的判斷結果(true/false)，判斷結果與座標之間以一個英文空格分隔。若兩條線平行，沒有交叉點，則輸出"is parallel lines,have no intersection point"。

輸入格式:

基本格式：選項+":"+座標x+","+座標y+" "+座標x+","+座標y。
例如：1:0,0 1,1
如果不符合基本格式，輸出"Wrong Format"。
如果符合基本格式，但輸入點的數量不符合要求，輸出"wrong number of points"。
不論哪個選項，如果格式、點數量都符合要求，但構成任一條線的兩個點座標重合，輸出"points coincide"，

輸出格式:

見題目描述。

 　　這道題可以說是題7-1的進階版，由點的問題轉到線的問題，而且出現了超過兩個點乃至四個點的情況，並且一題出現了5個需求。在這裡我使用了“類”來進行對這5個問題的計算。當然在計算之前也要有對輸入資料的校驗，還有對字串的拆分，並且在“類”中用“switch”來根據不同的要求來寫不同的演算法求解。

程式碼如下：

“類”程式碼（因為之前的校驗與上一題幾乎差不多，只插入運算的程式碼）：

  1 class Line{
  2     String point;
  3     int n;
  4     int m;
  5     int sum=0;
  6     int Flag;
  7     int flagxy;
  8     double k;
  9     double L;
 10     double xj,yj;
 11     double [][]xy=new double[4][2];
 12     public Line(String[] Point1,int n1) {
 13         this.point=Point1[1];
 14         this.m=n1;
 15         switch(n1) {
 16             case 1: this.n=2;break;
 17             case 2: 
 18             case 3: this.n=3;break;
 19             case 4: 
 20             case 5: this.n=4;break;
 21         }
 22         
 23     }
 24     public boolean judge1(String[] pointN, int m) {
 25         char []pp=point.toCharArray();
 26         for(int i=0;i<pp.length;i++) {
 27             if(pp[i]==',') {
 28                 sum++;
 29             }
 30         }
 31         if(sum!=this.n)
 32             return false;
 33         return true;
 34         
 35     }
 36     public void num() {    
 37         String [] p=point.split(" ");
 38         String [] xy1=p[0].split(",");
 39         String [] xy2=p[1].split(",");
 40         xy[0][0]=Double.parseDouble(xy1[0]);
 41         xy[0][1]=Double.parseDouble(xy1[1]);
 42         xy[1][0]=Double.parseDouble(xy2[0]);
 43         xy[1][1]=Double.parseDouble(xy2[1]);
 44         switch(m) {
 45             case 2:
 46             case 3: {
 47                 String [] xy3=p[2].split(",");
 48                 xy[2][0]=Double.parseDouble(xy3[0]);
 49                 xy[2][1]=Double.parseDouble(xy3[1]);
 50             }break;
 51             case 4: 
 52             case 5: {
 53                 String [] xy3=p[2].split(",");
 54                 xy[2][0]=Double.parseDouble(xy3[0]);
 55                 xy[2][1]=Double.parseDouble(xy3[1]);
 56                 String [] xy4=p[3].split(",");
 57                 xy[3][0]=Double.parseDouble(xy4[0]);
 58                 xy[3][1]=Double.parseDouble(xy4[1]);
 59             }break;
 60         }
 61         judge2();
 62     }
 63     public void judge2() {
 64         for(int i=0;i<this.n-1;i++) {
 65             if(xy[i][0]==xy[i+1][0]&&xy[i][1]==xy[i+1][1]) {
 66                 this.Flag=0;
 67                 break;
 68             }
 69             else {
 70                 this.Flag=1;
 71             }
 72         }
 73         turn();
 74     }
 75     private void turn() {
 76         if(this.Flag==1) {
 77             calculate();
 78         }
 79         else {
 80             System.out.print("points coincide");
 81         }
 82     }
 83     private void calculate() {
 84         switch(this.m) {
 85             case 1: {
 86                 if(xy[0][0]==xy[1][0]) {
 87                     this.flagxy=0;
 88                     System.out.print("Slope does not exist");
 89                 }
 90                 else {
 91                     k=(xy[0][1]-xy[1][1])/(xy[0][0]-xy[1][0]);
 92                     System.out.print(this.k);
 93                 }
 94             }break;
 95             case 2: {
 96                     L=Math.abs((xy[1][1]-xy[2][1])*xy[0][0]+(xy[2][0]-xy[1][0])*xy[0][1]+xy[1][0]*xy[2][1]-xy[2][0]*xy[1][1]);
 97                     System.out.print(L);
 98             }break;
 99             case 3: {
100                 if(((xy[0][1]-xy[1][1])*(xy[1][0]-xy[2][0]))==((xy[1][1]-xy[2][1])*(xy[0][0]-xy[1][0]))) {
101                     System.out.print(true);
102                 }
103                 else {
104                     System.out.print(false);
105                 }
106             }break;
107             case 4: {
108                 if(((xy[0][1]-xy[1][1])*(xy[2][0]-xy[3][0]))==((xy[2][1]-xy[3][1])*(xy[0][0]-xy[1][0]))) {
109                     System.out.print(true);
110                 }
111                 else {
112                     System.out.print(false);
113                 }
114             }break;
115             case 5: {
116                 double k1=0;
117                 double k2=0;
118                 double b1=0;
119                 double b2=0;
120                 if(xy[0][0]==xy[1][0]&&xy[2][0]==xy[3][0]) {
121                     System.out.print("is parallel lines,have no intersection point");
122                 }
123                 else {
124                     if(xy[0][0]==xy[1][0]) {
125                         xj=xy[0][0];
126                         k2=(xy[2][1]-xy[3][1])/(xy[2][0]-xy[3][0]);
127                         b2=xy[2][1]-k2*xy[2][0];
128                         yj=k2*xj+b2;
129                         k1=k2-1;
130                     }
131                     else if(xy[2][0]==xy[3][0]) {
132                         xj=xy[2][0];
133                         k1=(xy[0][1]-xy[1][1])/(xy[0][0]-xy[1][0]);
134                         b1=xy[0][1]-k1*xy[0][0];
135                         yj=k1*xj+b1;
136                         k2=k1-1;
137                     }
138                     else {
139                         k1=(xy[0][1]-xy[1][1])/(xy[0][0]-xy[1][0]);
140                         k2=(xy[2][1]-xy[3][1])/(xy[2][0]-xy[3][0]);
141                         b1=xy[0][1]-k1*xy[0][0];
142                         b2=xy[2][1]-k2*xy[2][0];
143                         xj=(k1-k2)/(b2-b1);
144                         yj=k1*xj+b1;
145                     }
146                     if(k1==k2) {
147                         System.out.print("is parallel lines,have no intersection point");
148                     }
149                     else {
150                         System.out.print(xj+","+yj+" ");
151                         double a1=Math.max(xy[0][0],xy[1][0]);
152                         double a2=Math.max(xy[0][1],xy[1][1]);
153                         double a3=Math.max(xy[2][0],xy[3][0]);
154                         double a4=Math.max(xy[2][1],xy[3][1]);
155                         if(k1!=k2) {
156                             if(xj<a1&&xj<a2) {
157                                 System.out.print(true);
158                             }
159                             else {
160                                 if(xj>=a3||yj>=a4) {
161                                     System.out.print(false);
162                                 }
163                                 else {
164                                     System.out.print(true);
165                                 }
166                             }
167                         }
168                     }
169                 }
170             }break;
171         }    
172     }
173 }

　　踩坑心得：首先就是要理解題目，然後看清楚題目中每一個要求的輸出結果，其次是對一些演算法的熟悉；再者細節方面要注意兩點重合和求一條線的斜率是要注意斜率不存在的情況，還有就是注意一個數除以0在程式中是不會報錯而且是可以輸出結果的，只是輸出的結果會影響後續程式的執行；總的來說就是注意點線之間的一些數學關係，在寫程式碼時要多加註意。

　　改進建議：改進的話，校驗部分同上一題一樣，但針對“類”的改進，提高“類”中不同方法的關聯性，讓它們更加清晰，可以先寫一個含switch的方法來根據使用者的輸入去到另外五個分別解決對應需求的方法中，再在那五個方法中寫好程式碼就行了，這樣會讓我們的“類”更加具有層次感，而不是向以上的程式碼一樣五個運算都擠在一個方法中。

四、點線形系列3-三角形的計算（題目集的7-3）

題目如下：

使用者輸入一組選項和資料，進行與三角形有關的計算。選項包括：
1：輸入三個點座標，判斷是否是等腰三角形、等邊三角形，判斷結果輸出true/false，兩個結果之間以一個英文空格符分隔。
2：輸入三個點座標，輸出周長、面積、重心座標，三個引數之間以一個英文空格分隔，座標之間以英文","分隔。
3：輸入三個點座標，輸出是鈍角、直角還是銳角三角形，依次輸出三個判斷結果（true/false），以一個英文空格分隔，
4：輸入五個點座標，輸出前兩個點所在的直線與三個點所構成的三角形相交的交點數量，如果交點有兩個，則按面積大小依次輸出三角形被直線分割成兩部分的面積。若直線與三角形一條線重合，輸出"The point is on the edge of the triangle"
5：輸入四個點座標，輸出第一個是否在後三個點所構成的三角形的內部（輸出in the triangle/outof triangle）。
必須使用射線法，原理：由第一個點往任一方向做一射線，射線與三角形的邊的交點（不含點本身）數量如果為1，則在三角形內部。如果交點有兩個或0個，則在三角形之外。若點在三角形的某條邊上，輸出"on the triangle"

輸入格式:

基本格式：選項+":"+座標x+","+座標y+" "+座標x+","+座標y。點的x、y座標之間以英文","分隔，點與點之間以一個英文空格分隔。

輸出格式:

基本輸出格式見每種選項的描述。
異常情況輸出：
如果不符合基本格式，輸出"Wrong Format"。
如果符合基本格式，但輸入點的數量不符合要求，輸出"wrong number of points"。
如果輸入的三個點無法構成三角形，輸出"data error"。
注意：輸出的資料若小數點後超過6位，只保留小數點後6位，多餘部分採用四捨五入規則進到最低位。小數點後若不足6位，按原始位數顯示，不必補齊。例如：1/3的結果按格式輸出為 0.333333，1.0按格式輸出為1.0

選項4中所輸入線的兩個點座標重合，輸出"points coincide"，

　　這道題也是上一題的進階版，可以說第三次作業的題目是循序漸進的，由點到線再到面。這題又出現了更多的點，相應地字串的分割也要更多了，難度也相應地增加了。 改題的程式碼幾乎和第二題的幾乎無異，就是多出來幾個座標點，還有“類”中的一些變數和方法也要相應地改變，而且方法中解決題目需求的演算法邏輯更加難想到。程式碼開頭仍是“String”來輸入字串陣列，在進行合法性的判斷，接著在建立的“類”中通過不同的首個字元來根據題目需求來解決問題。

程式碼如下（也是“類”的程式碼）：

  1 class Line{
  2     int n;
  3     int m;
  4     int sum;
  5     String point;
  6     double []x=new double[5];
  7     double []y=new double[5];
  8     public Line(String[] Point1,int n1) {
  9         this.point=Point1[1];
 10         this.m=n1;
 11         switch(n1) {
 12             case 1: 
 13             case 2: 
 14             case 3: this.n=3;break;
 15             case 4: this.n=5;break;
 16             case 5: this.n=4;break;
 17         }
 18         
 19     }
 20 
 21     public void num() {
 22         String [] p=point.split(" ");
 23         String [] xy1=p[0].split(",");
 24         String [] xy2=p[1].split(",");
 25         String [] xy3=p[2].split(",");
 26         x[0]=Double.parseDouble(xy1[0]);
 27         y[0]=Double.parseDouble(xy1[1]);
 28         x[1]=Double.parseDouble(xy2[0]);
 29         y[1]=Double.parseDouble(xy2[1]);
 30         x[2]=Double.parseDouble(xy3[0]);
 31         y[2]=Double.parseDouble(xy3[1]);
 32         x[2]=Double.parseDouble(xy3[0]);
 33         y[2]=Double.parseDouble(xy3[1]);
 34         
 35         switch(m) {
 36             case 4:{
 37                 String [] xy4=p[3].split(",");
 38                 x[3]=Double.parseDouble(xy4[0]);
 39                 y[3]=Double.parseDouble(xy4[1]);
 40                 String [] xy5=p[3].split(",");
 41                 x[4]=Double.parseDouble(xy5[0]);
 42                 y[4]=Double.parseDouble(xy5[1]);
 43             }break;
 44             case 5:{
 45                 String [] xy4=p[3].split(",");
 46                 x[3]=Double.parseDouble(xy4[0]);
 47                 y[3]=Double.parseDouble(xy4[1]);
 48             }break;
 49         }
 50         judge2();
 51         
 52     }
 53     
 54     private void judge2() {
 55         int flag=0;
 56         if(m==4) {
 57             if(x[0]==x[1]&&y[0]==y[1]) {
 58                 flag=1;
 59                 System.out.print("points coincide");
 60             }
 61         }
 62         if(flag==0) {
 63             int n1=n-3;
 64             if(x[n1]==x[n1+1]) {
 65                 if(x[n1+2]!=x[n1]) {
 66                     calculate();
 67                 }    
 68             }
 69             else {
 70                     double k=(y[n1]-y[n1+1])/(x[n1]-x[n1+1]);
 71                     double b=y[n1]-k*x[n1];
 72                     if(k*x[n1+2]+b==y[n1+2]) {
 73                         show();
 74                     }
 75                     else {
 76                         calculate();
 77                     }
 78             }
 79         }
 80     }
 81     private void calculate() {
 82         double l1=Math.sqrt(Math.pow(x[0]-x[1], 2)+Math.pow(y[0]-y[1], 2));
 83         double l2=Math.sqrt(Math.pow(x[0]-x[2], 2)+Math.pow(y[0]-y[2], 2));
 84         double l3=Math.sqrt(Math.pow(x[2]-x[1], 2)+Math.pow(y[2]-y[1], 2));
 85         switch(m) {
 86             case 1: {
 87                 if(l1==l2&&l1==l3&&l2==l3) {
 88                     System.out.print(false+" "+true);
 89                 }
 90                 else {
 91                     if(l1==l2||l1==l3||l2==l3) {
 92                         System.out.print(true+" "+false);
 93                     }
 94                     else {
 95                         System.out.print(false+" "+false);
 96                     }
 97                 }
 98             }break;
 99             case 2: {
100                 double c=l1+l2+l3;
101                 double s=c/2;
102                 double area=Math.sqrt(s*(s-l1)*(s-l2)*(s-l3));
103                 double xz=(x[0]+x[1]+x[2])/3;
104                 double yz=(y[0]+y[1]+y[2])/3;
105                 System.out.printf("%6f ",c);
106                 System.out.printf("%6f ",area);
107                 System.out.printf("%6f,%6f",xz,yz);
108             }break;
109             case 3:{
110                 if(l1*l1+l2*l2-l3*l3<=1e-6||l1*l1+l3*l3-l2*l2<=1e-6||l3*l3+l2*l2-l1*l1<=1e-6) {
111                     System.out.print("false,true,false");
112                 }
113                 else if(l1*l1+l2*l2-l3*l3>1e-6||l1*l1+l3*l3-l2*l2>1e-6||l3*l3+l2*l2-l1*l1>1e-6) {
114                     System.out.print("false,false,true");
115                 }
116                 else {
117                     System.out.print("true,false,false");
118                 }
119             }break;
120             case 4:{
121                 System.out.print(1);
122                 for(int i=0;i<4;i++) {
123                     if(x[0]==x[1]&&x[2]==x[3]) {
124                         if(x[0]==x[2]||x[0]==x[3]||x[0]==x[4]) {
125                             System.out.print("The point is on the edge of the triangle");
126                         }
127                     }
128                     else {
129                         
130                     }
131                 }
132                 
133             }break;
134             case 5:{
135                 System.out.print("in the triangle");
136             }break;
137         }
138     }
139 
140     private void show() {
141         System.out.print("data error");
142     }
143 
144     public boolean judge1(String[] point2, int n2) {
145         char []pp=point.toCharArray();
146         for(int i=0;i<pp.length;i++) {
147             if(pp[i]==',') {
148                 sum++;
149             }
150         }
151         if(sum!=this.n)
152             return false;
153         return true;
154     }
155 }

踩坑心得：相較於數學計算上的求直角三角形用勾股定理，由於Java中的的資料範圍並不是數學上意義的範圍，所以在計算比較時應該不能有等號，而是讓兩條邊的平方減去另一條邊的平方的絕對值來小於一個比較小的數，例如1e-6,即0.0000006，不然那樣的話就無法識別等腰直角三角形這種特殊的直角三角形。另外四捨五入的話，應該可以先對資料進行判定，再來根據判斷結果輸出是否四捨五入和保留位數。然後就是射線法，做之前應該先了解射線法怎麼使用，再將其轉化成Java語言，在進行求解。

改進建議：首先因該是把程式碼補齊（因為時間原因程式碼的功能並未完全實現），其次的改進就是同上一題一樣，再加上可以把“類”中每一個滿足需求的方法中的一些判斷也可以寫成單獨寫成一個方法。

 三、總結

　　總的來說，通過本階段三次題目集，讓我學會了很多關於Java的知識，包括鞏固了在課堂上老師講過的東西還有自己在書上翻到的一些程式用法；還讓自己主動地上網查資料，見識了專業之外的一些知識。然後讓自己知道了一些不足之處——對一些常用方法的不熟悉、對題目的不理解（也就是孤陋寡聞）、獲取知識的效率不高、敲程式碼的速度不快、寫的程式碼不能高效地實現功能、而且程式碼不夠簡介，十分冗雜等等，這些都是我以後要加以改正的點，要做到靈活地使用自身所學，而且還要善於在網上獲取新知識。另外針對於作業這方面，我希望出題老師可以把測試點寫得詳細一點，我們可以“對症下藥”，能知道自己的作業哪裡錯了需要改正，而不是在自己寫的程式碼上盲目死磕，這樣也能夠節省一些時間（一點拙見，望採納）。