前三次作业总结

1.前言：

    前三次题目集主要关于java语言的基本程序设计，知识点涉及从最基础的命名变量到对象和类，其中包括了选择结构，循环结构，数学函数，字符和字符串以及方法的定义与调用，还有数组的使用等内容。题量适中，均能在规定时间内做完，但不一定能做全对。难度循序渐进，从第一次的基础题目到第三次的进阶题目，普遍基本思路不难，但是一开始敲击代码就会发现细节很难把握到位，尤其是有关于输入测试的部分尤为突出，明显很难考虑到每一个方面以至于无法拿到满分，总会有测试点过不了。第三次题目最难，不但体现于输入方面，在整体计算中也有体现，涉及不少数学知识，无论是第二道题目的直线之前的关系还是第三道题的三角形有关计算都不简单，转化为代码后更能复杂，需要一定的时间。

    总的来说，Java又是我们本学期第一次接触的语言，对Java语言的运用还有些许生疏，对语法的理解和java整体的结构把握不够清晰以及有关与行间距的习惯等还有很大进步空间，需要加强训练以求熟练。

2.设计分析：

    7-2 第二题串口字符解析，以下为代码：

import java.util.Scanner;

public class Main{
    public static void output(String str1,int n){
        int count = 0;
        for(int j=0;j<str1.length()-1;j++)
        if(str1.charAt(j) == '1')
                count++;
        if(count%2 == 0&&str1.charAt(10) == '1')
                System.out.println(n+":"+"parity check error");
        if(count%2 != 0&&str1.charAt(10) != '1')
                System.out.println(n+":"+"validate error");
        if(count%2 == 0&&str1.charAt(10) != '1')
                System.out.println(n+":"+"validate error");
        if(count%2 != 0&&str1.charAt(10) == '1')
                System.out.println(n+":"+str1.substring(1,9));
    }
    public static void main(String []args){
        Scanner input = new Scanner(System.in);
        
        int flag = 0;
        int seat = 0;
        int time = 1;
        String str1;
        String []arr = new String[100];
        str1 = input.nextLine();
        
        if(str1.length()<11)
            System.out.print("null data");
        else {
            for(int i=0;i<str1.length()-10;i++){
                if(str1.charAt(i)=='0'){
                    seat = i;
                    flag = 1;
                    break;
                }
            }
            if(flag == 0)
             System.out.print("null data");
            arr[0] = str1.substring(seat,seat+11);
            if(flag == 1){
                for(int m=seat+11;m<str1.length()-10;m++){
                if(str1.charAt(m)=='0'){
                    seat = m;
                    arr[time] = str1.substring(seat,seat+11);
                    time ++;
                    m=seat+10;
                        }
                }
                for(int n=0;n<time;n++){
                    output(arr[n],n+1);
                }
            }
            }
        }
}

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

    代码分析：1.输入判断：

• 输入数据必须满足11位及以上且必须有起始位"0"。

  　　　　　　2.数据处理：

• 判断输入中的数据是否大于11位，若小于11位则数据中一定没有有效数据。
• 起始位的判断，先将数据从第一个开始读到倒数第10位，若其中有"0"，则输入中有有效数据。
• 定义一个int类型的数组time和一个string类型的数组str，从第一个起始位开始将后面11位全存入str数组中，后找到第二个起始位......以此类推
• 得到不同的有效数据后进行奇偶校验和结束符检验，结束符必须为"1"且奇偶效验采用奇效验，若8位数据中的前6位里"1"的个数为奇数则第7位数据为"0"，反之若前6位里"1"的个数为偶数则第7位数据为"1"。

　　　　　　3.输出处理：

• 若数据不足11位或者输入数据全1没有起始位，则输出"null data"。
• 若某个数据的结束符不为1，则输出"validate error"。
• 若某个数据奇偶校验错误，则输出"parity check error"。　
• 若数据结束符和奇偶校验均不合格，则输出"validate error"。
• 若有多个数据，每个数据单独一行显示。　　　

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

import java.util.Scanner;

public class Main
{
    public static void main(String[] args)
    {
        Scanner scan = new Scanner(System.in);
        String s = new String();
        s = scan.nextLine();
        int flag = 1;
        int k = 0;
        int count=0;
        
        for(int i = 0;i<s.length();i++)
        {
            if(s.charAt(i)==',')
                {
                   count++;
                }
            if(s.charAt(i)==' ')
                {
                   k++;
                }
            if(s.charAt(i)=='+'||s.charAt(i)=='-'||s.charAt(i)=='.')
            {
                if(s.charAt(i+1)>='0'&&s.charAt(i+1)<='9')
                {
                    continue;
                }
                else
                {
                    flag = 0;
                    break;
                }
            }
        }
                if(count - k != 1)
            flag = 0;
        if(flag==1)
        {
            if(count!=2)
            {
                System.out.println("wrong number of points");
            }
            else
            {
                String[] a = new String[4];
                for(int i = 0;i<4;i++)
                {
                    a[i] = new String();
                }
                int cnt = 0;
                for(int i = 0;i<s.length();i++)
                {
                    if(s.charAt(i)!=' '&&s.charAt(i)!=',')
                    {
                        a[cnt] = a[cnt]+s.substring(i,i+1);
                    }
                    else
                    {
                        cnt++;
                    }
                }
                int flag1 = 1;
                for(int i = 0;i<4;i++){
                    if(a[i].charAt(0)=='+'||a[i].charAt(0)=='-')
                   {
                       if(a[i].charAt(1)=='0'&&a[i].charAt(2)!='.')
                       {
                           flag1=0;
                       }
                   }
                   else
                   {
                       if(a[i].length()>=2)
                       {
                           if(a[i].charAt(0)=='0'&&a[i].charAt(1)!='.')
                           {
                               flag1=0;
                           }
                       }
                   }
                   if(flag1==0)
                   {
                       
                       break;
                   }
                }
                if(flag1==0)
                {
                    System.out.println("Wrong Format");
                }
                else{
                double m,n,p,q;
                m=Double.parseDouble(a[0]);
                n=Double.parseDouble(a[1]);
                p=Double.parseDouble(a[2]);
                q=Double.parseDouble(a[3]);
                double distance = Math.sqrt((m-p)*(m-p)+(n-q)*(n-q));
                System.out.println(distance);
                }
            }
        }
        else
        {
            System.out.println("Wrong Format");
        }
    }
}

 　　本题难点主要体现：

• 输入的判断，输入中有空格和字符","的出现，对输入判断不方便。
• 两点间距离公式的运用。

　　代码分析：1.输入判断：

• 输入数据必须为两个点坐标。
• 两个点的坐标之间以空格分隔。
• 每个点的x,y坐标以英文“,”分隔。
• 每个数字前"+","-"只能有一个。

  　　　　　　2.数据处理：

• 定义一个字符串str，将输入数据存入其中。
• 判断断输入中的数据是否为两个点，两个点的坐标之间以空格分隔，每个点的x,y坐标以英文“,”分隔。
• 判断每个数字前"+","-"是否只有一个。
• 判断输入的数字是否符合要求。
• 运用数学函数计算两点间的距离并保留小数点后十五位输出。

　　　　　　3.输出处理：

• 若输入格式非法，输出"Wrong Format"。
• 若输入格式合法但坐标点的数量超过两个，输出“wrong number of points”。
• 若输入数据合法则输出距离并保留小数点后十五位。　

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

import java.util.Scanner;

public class Main {

        public static void main(String[] args) {
            double x1,y1,x2,y2;
            char a,b;
            int flag = 1;
            int count = 0;
            int k = 0;
            Scanner in = new Scanner(System.in);
            String str = in.nextLine();
            int time = (int)(str.charAt(0))-48;
            
            if(str.charAt(0) >= '1'&&str.charAt(0) <= '5'&&str.charAt(1) == ':'){
                for(int i = 2;i<str.length();i++){
                        if(str.charAt(i)==',')
                        {
                        count++;
                        }
                        if(str.charAt(i)==' ')
                        {
                         k++;
                        }
                        if(str.charAt(i)=='+'||str.charAt(i)=='-'||str.charAt(i)=='.'){
                            if(str.charAt(i+1)>='0'&&str.charAt(i+1)<='9'){
                                continue;
                            }
                            else{
                                flag = 0;
                                break;
                        }
                    }
                }
            if(count - k != 1)
                flag = 0;
            }
            else{
                System.out.println("Wrong Format");
            }
            if(flag == 0)
                System.out.println("Wrong Format");
            if(flag == 1){
                switch(time){
                    case 1:
                        qingkuang1(str);break;
                    case 2:
                        qingkuang2(str);break;
                    case 3:
                        qingkuang3(str);break;
                    case 4:
                        qingkuang4(str);break;
                    case 5:
                        qingkuang5(str);break;
                }
            }
        }
    
    
        public static int shuliang(String str){
            int count = 0;
            for(int i = 0;i<str.length();i++){
                if(str.charAt(i) == ',')
                    count ++;
            }
            return count;
        }
    
    
        public static boolean panduan(double x1,double y1,double x2,double y2){
            if(x1 == x2&&y1 == y2)
            return false;
            return true;
        }
    
    
        public static void qingkuang1(String str){
            int count = 0;
            boolean flag = true;
            count = shuliang(str);
            if(count != 2)
                System.out.println("wrong number of points");
            else{
            String[] a = new String[4];
                for(int i = 0;i<4;i++)
                {
                    a[i] = new String();
                }
                int cnt = 0;
                for(int i = 2;i<str.length();i++)
                {
                    if(str.charAt(i)!=' '&&str.charAt(i)!=',')
                    {
                        a[cnt] = a[cnt]+str.substring(i,i+1);
                    }
                    else
                    {
                        cnt++;
                    }
                }
                int flag1=1;
               for(int i = 0;i<count*2;i++)
               {
                   if(a[i].charAt(0)=='+'||a[i].charAt(0)=='-')
                   {
                       if(a[i].charAt(1)=='0'&&a[i].charAt(2)!='.')
                       {
                           flag1=0;
                       }
                   }
                   else
                   {
                       if(a[i].length()>=2)
                       {
                           if(a[i].charAt(0)=='0'&&a[i].charAt(1)!='.')
                           {
                               flag1=0;
                           }
                       }
                   }
                   if(flag1==0)
                   {
                       
                       break;
                   }
               }
                if(flag1==0)
                {
                    System.out.println("Wrong Format");
                }
                else{
                double [] arr = new double[count*2];
                for(int i = 0;i<count*2;i++)
                    arr[i] = Double.parseDouble(a[i]);
                flag = panduan(arr[0],arr[1],arr[2],arr[3]);
                if(flag){
                if(arr[0]-arr[2] == 0)
                    System.out.println("Slope does not exist");
                else{
                double k = (arr[1]-arr[3]) / (arr[0]-arr[2]);
                System.out.println(k);
                }
                }
                else
                System.out.println("points coincide");
                }
            }
        }
    
    
    public static void qingkuang2(String str){
            int count = 0;
            boolean flag = true;
            double A,B,C;
            count = shuliang(str);
            if(count != 3)
                System.out.println("wrong number of points");
            else{
            String[] a = new String[6];
                for(int i = 0;i<6;i++)
                {
                    a[i] = new String();
                }
                int cnt = 0;
                for(int i = 2;i<str.length();i++)
                {
                    if(str.charAt(i)!=' '&&str.charAt(i)!=',')
                    {
                        a[cnt] = a[cnt]+str.substring(i,i+1);
                    }
                    else
                    {
                        cnt++;
                    }
                }
                int flag1=1;
               for(int i = 0;i<count*2;i++)
               {
                   if(a[i].charAt(0)=='+'||a[i].charAt(0)=='-')
                   {
                       if(a[i].charAt(1)=='0'&&a[i].charAt(2)!='.')
                       {
                           flag1=0;
                       }
                   }
                   else
                   {
                       if(a[i].length()>=2)
                       {
                           if(a[i].charAt(0)=='0'&&a[i].charAt(1)!='.')
                           {
                               flag1=0;
                           }
                       }
                   }
                   if(flag1==0)
                   {
                       
                       break;
                   }
               }
                if(flag1==0)
                {
                    System.out.println("Wrong Format");
                }
                else{
                double [] arr = new double[count*2];
                for(int i = 0;i<count*2;i++)
                    arr[i] = Double.parseDouble(a[i]);
                flag = panduan(arr[0],arr[1],arr[2],arr[3]);
                flag = panduan(arr[0],arr[1],arr[4],arr[5]);
                flag = panduan(arr[2],arr[3],arr[4],arr[5]);
                if(flag){
                    A = arr[5] - arr[3];
                    B = arr[2] - arr[4];
                    C = arr[4]*arr[3] - arr[5]*arr[2];
                    double distance = (Math.abs(A*arr[0] + B*arr[1] + C)) / (Math.sqrt(A*A + B*B));
                    System.out.println(distance);
                }
                else
                System.out.println("points coincide");
                }
            }
        }
    
    
    public static void qingkuang3(String str){
            int count = 0;
            boolean flag = true;
            boolean answer;
            count = shuliang(str);
            if(count != 3)
                System.out.println("wrong number of points");
            else{
            String[] a = new String[6];
                for(int i = 0;i<6;i++)
                {
                    a[i] = new String();
                }
                int cnt = 0;
                for(int i = 2;i<str.length();i++)
                {
                    if(str.charAt(i)!=' '&&str.charAt(i)!=',')
                    {
                        a[cnt] = a[cnt]+str.substring(i,i+1);
                    }
                    else
                    {
                        cnt++;
                    }
                }
                int flag1=1;
               for(int i = 0;i<count*2;i++)
               {
                   if(a[i].charAt(0)=='+'||a[i].charAt(0)=='-')
                   {
                       if(a[i].charAt(1)=='0'&&a[i].charAt(2)!='.')
                       {
                           flag1=0;
                       }
                   }
                   else
                   {
                       if(a[i].length()>=2)
                       {
                           if(a[i].charAt(0)=='0'&&a[i].charAt(1)!='.')
                           {
                               flag1=0;
                           }
                       }
                   }
                   if(flag1==0)
                   {
                       break;
                   }
               }
                if(flag1==0)
                {
                    System.out.println("Wrong Format");
                }
                else{
                double [] arr = new double[count*2];
                for(int i = 0;i<count*2;i++)
                    arr[i] = Double.parseDouble(a[i]);
                flag = panduan(arr[0],arr[1],arr[2],arr[3]);
                flag = panduan(arr[0],arr[1],arr[4],arr[5]);
                flag = panduan(arr[2],arr[3],arr[4],arr[5]);
                if(flag){
                    double k1 = (arr[1]-arr[3]) / (arr[0]-arr[2]);
                    double k2 = (arr[1]-arr[5]) / (arr[0]-arr[4]);
                    if(k1 == k2)
                        answer = true;
                    else
                        answer = false;
                    System.out.println(answer);
                }
                else
                System.out.println("points coincide");
                }
            }
        }
    
    
        public static void qingkuang4(String str){
            int count = 0;
            boolean flag = true;
            boolean answer;
            count = shuliang(str);
            if(count != 4)
                System.out.println("wrong number of points");
            else{
            String[] a = new String[count*2];
                for(int i = 0;i<count*2;i++)
                {
                    a[i] = new String();
                }
                int cnt = 0;
                for(int i = 2;i<str.length();i++)
                {
                    if(str.charAt(i)!=' '&&str.charAt(i)!=',')
                    {
                        a[cnt] = a[cnt]+str.substring(i,i+1);
                    }
                    else
                    {
                        cnt++;
                    }
                }
               int flag1=1;
               for(int i = 0;i<count*2;i++)
               {
                   if(a[i].charAt(0)=='+'||a[i].charAt(0)=='-')
                   {
                       if(a[i].charAt(1)=='0'&&a[i].charAt(2)!='.')
                       {
                           flag1=0;
                       }
                   }
                   else
                   {
                       if(a[i].length()>=2)
                       {
                           if(a[i].charAt(0)=='0'&&a[i].charAt(1)!='.')
                           {
                               flag1=0;
                           }
                       }
                   }
                   if(flag1==0)
                   {
                       
                       break;
                   }
               }
                if(flag1==0)
                {
                    System.out.println("Wrong Format");
                }
                else{
                double [] arr = new double[count*2];
                for(int i = 0;i<count*2;i++)
                    arr[i] = Double.parseDouble(a[i]);
                flag = panduan(arr[0],arr[1],arr[2],arr[3]);
                flag = panduan(arr[0],arr[1],arr[4],arr[5]);
                flag = panduan(arr[0],arr[1],arr[6],arr[7]);
                flag = panduan(arr[2],arr[3],arr[4],arr[5]);
                flag = panduan(arr[2],arr[3],arr[6],arr[7]);
                flag = panduan(arr[4],arr[5],arr[6],arr[7]);
                if(flag){
                    double k1 = (arr[1]-arr[3]) / (arr[0]-arr[2]);
                    double k2 = (arr[5]-arr[7]) / (arr[4]-arr[6]);
                    if(k1 == k2)
                        answer = true;
                    else
                        answer = false;
                    System.out.println(answer);
                }
                else
                System.out.println("points coincide");
                }
            }
        }
    
    
    public static void qingkuang5(String str){
            int count = 0;
            boolean flag = true;
            boolean answer;
            double A1,A2,B1,B2,C1,C2;
            count = shuliang(str);
            if(count != 4)
                System.out.println("wrong number of points");
            else{
            String[] a = new String[count*2];
                for(int i = 0;i<count*2;i++)
                {
                    a[i] = new String();
                }
                int cnt = 0;
                for(int i = 2;i<str.length();i++)
                {
                    if(str.charAt(i)!=' '&&str.charAt(i)!=',')
                    {
                        a[cnt] = a[cnt]+str.substring(i,i+1);
                    }
                    else
                    {
                        cnt++;
                    }
                }
               int flag1=1;
               for(int i = 0;i<count*2;i++)
               {
                   if(a[i].charAt(0)=='+'||a[i].charAt(0)=='-')
                   {
                       if(a[i].charAt(1)=='0'&&a[i].charAt(2)!='.')
                       {
                           flag1=0;
                       }
                   }
                   else
                   {
                       if(a[i].length()>=2)
                       {
                           if(a[i].charAt(0)=='0'&&a[i].charAt(1)!='.')
                           {
                               flag1=0;
                           }
                       }
                   }
                   if(flag1==0)
                   {
                       
                       break;
                   }
               }
                if(flag1==0)
                {
                    System.out.println("Wrong Format");
                }
                else{
                double [] arr = new double[count*2];
                for(int i = 0;i<count*2;i++)
                    arr[i] = Double.parseDouble(a[i]);
                flag = panduan(arr[0],arr[1],arr[2],arr[3]);
                flag = panduan(arr[0],arr[1],arr[4],arr[5]);
                flag = panduan(arr[0],arr[1],arr[6],arr[7]);
                flag = panduan(arr[2],arr[3],arr[4],arr[5]);
                flag = panduan(arr[2],arr[3],arr[6],arr[7]);
                flag = panduan(arr[4],arr[5],arr[6],arr[7]);
                if(flag){
                    double k1 = (arr[1]-arr[3]) / (arr[0]-arr[2]);
                    double k2 = (arr[5]-arr[7]) / (arr[4]-arr[6]);
                    if(k1 == k2)
                        System.out.println("is parallel lines,have no intersection point");
                    else{
                        A1 = arr[3] - arr[1];
                        B1 = arr[0] - arr[2];
                        C1 = arr[2]*arr[1] - arr[0]*arr[3];
                        A2 = arr[7] - arr[5];
                        B2 = arr[4] - arr[6];
                        C2 = arr[6]*arr[5] - arr[4]*arr[7];
                        double x = (B2*C1-B1*C2) / (A2*B1-A1*B2);
                        double y = (A1*C2-A2*C1) / (A2*B1-A1*B2);
                        if((x>arr[0]&&x>arr[2]&&x>arr[4]&&x>arr[6])||(x<arr[0]&&x<arr[2]&&x<arr[4]&&x<arr[6]))
                            answer = false;
                        else
                            answer = true;
                        System.out.println(x+","+y+" "+answer);
                    }
                }
                else
                System.out.println("points coincide");
                }
            }
        }
}

 

本题难点主要体现：

• 输入的判断，输入中有空格和字符","的出现，对输入判断不方便。
• 计算斜率。
• 输出第一个点与另外两点连线的垂直距离。
• 判断三个点是否在一条线上，输出true或者false。
• 判断前两个点所构成的直线与后两点构成的直线是否平行，输出true或者false。
• 计算输出前两个点所构成的直线与后两点构成的直线的交点坐标，x、y坐标之间以英文分隔","，并输出交叉点是否在两条线段之内（不含四个端点）的判断结果(true/false)。

　　代码分析：1.输入判断：

• 输入数据第一位必须是数字且为1-5。
• 第二位必须为":"。
• 输入的点的坐标必须和输入的第一位数字的对应情况对应。。
• 两个点的坐标之间以空格分隔。
• 每个点的x,y坐标以英文“,”分隔。
• 每个数字前"+","-"只能有一个。
• 必须符合基本格式：选项+":"+坐标x+","+坐标y+" "+坐标x+","+坐标y。

  　　　　　　2.数据处理：

• 定义一个字符串str，将输入数据存入其中。
• 定义一个int类型的变量存储str第一位数字。
• 对所给数据进行基本判断，看其是否符合基本格式。
• 运动switch语句，根据int所读入的数字确定为那种情况。
• 根据不同的情况判断输入数据是否符合规定。
• 若为情况1则计算两点的斜率。
• 若为情况2则运用数学公式，通过所给点坐标计算出距离，并输出。
• 若为情况3则计算任意两个的斜率是否相等，若相等则输出true反之不相等则输出false。
• 若为情况4则计算前两个点所构成的直线的斜率是否与后面一点相等，若相等则输出true反之不相等则输出false。
• 若为情况5则运用数学公式计算两直线交点坐标，并通过交点坐标的x，与其他四个点对比得出是否在两线段之中。

　　　　　　3.输出处理：

• 如果不符合基本格式，输出"Wrong Format"。
• 如果符合基本格式，但输入点的数量不符合要求，输出"wrong number of points"。
• 不论哪个选项，如果格式、点数量都符合要求，但构成任一条线的两个点坐标重合，输出"points coincide"。
• 计算斜率，若线条垂直于X轴，输出"Slope does not exist"。
• 判断三个点是否在一条线上，输出true或者false。
• 若两条线平行，没有交叉点，则输出"is parallel lines,have no intersection point"。
• 判断前两个点所构成的直线与后两点构成的直线是否平行，输出true或者false。

　　7-3 点线形系列3-三角形的计算 (48 分)

本题难点主要体现：

• 输入的判断，输入中有空格和字符","的出现，对输入判断不方便。
• 判断是否是等腰三角形、等边三角形。
• 计算周长、面积、重心坐标。
• 判断是钝角、直角还是锐角三角形。
• 输出前两个点所在的直线与三个点所构成的三角形相交的交点数量。
• 如果交点有两个，则按面积大小依次输出三角形被直线分割成两部分的面积。

　　代码分析：1.输入判断：

• 输入数据第一位必须是数字且为1-5。
• 第二位必须为":"。
• 输入的点的坐标必须和输入的第一位数字的对应情况对应。。
• 两个点的坐标之间以空格分隔。
• 每个点的x,y坐标以英文“,”分隔。
• 每个数字前"+","-"只能有一个。
• 必须符合基本格式：选项+":"+坐标x+","+坐标y+" "+坐标x+","+坐标y。

  　　　　　　2.数据处理：

• 定义一个字符串str，将输入数据存入其中。
• 定义一个int类型的变量存储str第一位数字。
• 对所给数据进行基本判断，看其是否符合基本格式。
• 运动switch语句，根据int所读入的数字确定为那种情况。
• 根据不同的情况判断输入数据是否符合规定。
• 若为情况1则断是否是等腰三角形、等边三角形，运用三边之间的关系。
• 若为情况2则运用数学公式，通过所给点坐标计算出周长、面积、重心坐标。
• 若为情况3则运用数学公式，通过三边的关系计算出是钝角、直角还是锐角三角形。
• 若为情况4则计算两个点所在的直线与三个点所构成的三角形相交的交点数量，如果交点有两个，则按面积大小依次输出三角形被直线分割成两部分的面积。
• 若为情况5则使用射线法，计算出第一个是否在后三个点所构成的三角形的内部。

　　　　　　3.输出处理：

• 如果不符合基本格式，输出"Wrong Format"。
• 如果符合基本格式，但输入点的数量不符合要求，输出"wrong number of points"。
• 如果输入的三个点无法构成三角形，输出"data error"。
• 选项4中所输入线的两个点坐标重合，输出"points coincide"，
• 若直线与三角形一条线重合，输出"The point is on the edge of the triangle"
• 输出第一个是否在后三个点所构成的三角形的内部（输出in the triangle/outof triangle）
• 判断是否是等腰三角形、等边三角形，判断结果输出true/false。
• 输出是钝角、直角还是锐角三角形，依次输出三个判断结果（true/false）。
• 输出周长、面积、重心坐标，输出的数据若小数点后超过6位，只保留小数点后6位，多余部分采用四舍五入规则进到最低位。小数点后若不足6位，按原始位数显示，不必补齐。

3.踩坑心得：

　　1.对输入的判断一定要谨慎，尤其是最后一次的三道题目，一开始我都是拿不到满分，后来发现多多少少都有受到输入的影响！尤其是第一道题，输入判断不只是对" " , "," , "+"此三个符号的判断还有很容易忽略的"."，所以发现了此问题后我就加上了一段新代码。

 

for(int i = 0;i<4;i++){
                    if(a[i].charAt(0)=='+'||a[i].charAt(0)=='-')
                   {
                       if(a[i].charAt(1)=='0'&&a[i].charAt(2)!='.')
                       {
                           flag1=0;
                       }
                   }
                   else
                   {
                       if(a[i].length()>=2)
                       {
                           if(a[i].charAt(0)=='0'&&a[i].charAt(1)!='.')
                           {
                               flag1=0;
                           }
                       }
                   }
                   if(flag1==0)
                   {
                       
                       break;
                   }
                }
                if(flag1==0)
                {
                    System.out.println("Wrong Format");
                }

 

此段代码尤为重要，是对"."的判断，若无此段代码则会出现譬如"+2.+"之类的格式错误。

2.对输出的小数点的控制，若想输出15为小数则需要使用println且需要时double类型的数据，如果用的是print则会自动保留两位小数导致输出不符合格式。

3.数学方法的运用，无论是第二题还是第三题，若选对了合适的数学方法，对整体数据的处理以及计算都会方便很多。譬如7-2的第二种情况，若使用两点式表达此直线在将其化为一般是，并求出对应A,B,C后在代入公式，整体思路会更简单。

else{
                double [] arr = new double[count*2];
                for(int i = 0;i<count*2;i++)
                    arr[i] = Double.parseDouble(a[i]);
                flag = panduan(arr[0],arr[1],arr[2],arr[3]);
                flag = panduan(arr[0],arr[1],arr[4],arr[5]);
                flag = panduan(arr[2],arr[3],arr[4],arr[5]);
                if(flag){
                    A = arr[5] - arr[3];
                    B = arr[2] - arr[4];
                    C = arr[4]*arr[3] - arr[5]*arr[2];
                    double distance = (Math.abs(A*arr[0] + B*arr[1] + C)) / (Math.sqrt(A*A + B*B));
                    System.out.println(distance);
                }
                else
                System.out.println("points coincide");
                }
            }
        }

4.switch语句的运用，若无break；则会导致一直输出错误。

5.在7-3中如果没有使用射线法则对整体计算有很大影响。

6.多if 的语句很可能会弄不清楚逻辑关系，不如使用flag等标志词，使逻辑更清晰。

int flag1 = 1;
boolean flag = true;

 

4.改进建议：

1. 整体代码的可读性需加强有很多地方重复性太高。
   

    2.对大作业2的7-2题，代码缩进不行，可读性差。

                        }
                }
                for(int n=0;n<time;n++){
                    output(arr[n],n+1);
                }
            }
            }
        }
}

     　　3.大作业三的7-1题目，判断条件重复性太高，而且逻辑性不够清晰。

　　　 4.大作业三的7-2题目，整体运用的方法多，但是很多方法的内部也可以简化出别的方法。

　　　5.大作业三的7-3题目，整体困难导致几种情况想不出来，而且整体对数学函数的运用和思路都需要大大提升。

5.总结：

　　本阶段三次题目集让我学到了基本的循环语句以及选择语言，尤其是更加熟练的运用字符串和字符串有关函数等等并让我更加熟练掌握了方法的运用和类的运用还有数学函数的运用等。对于类的运用和字符串以及数组等级基本类型的运用还需加强，尤其是一些基本语法。对整体的题目程序涉及方面还需加强，有很多地方可以简化运算和代码。代码的书写过程也需加强，很多题目的总体代码都存在重复性过高，可读性不强等问题。对方法的运用还需加强，熟练方法后可以增加代码可读性也能使代码更简单。

　作业的测试点可以增加多一些提示，譬如有些模糊不清的输入判断如果增加一些提示将会更好。整体题目的难度，就是第一次第二次比较简单，突然第三次特别难，我觉得可以第三次也有一些难题，但是也可以增加两道简单题有循序渐进的过程。