皓远的第二次博客作业(最新pta集，链表练习及期中考试总结)

前言：

• 知识点运用：正则表达式，有关图形设计计算的表达式和算法，链表的相关知识，Java类的基础运用，继承、容器与多态。
• 题量：相较于上次作业，这几周在java方面的练习花了更多的精力和时间，所要完成的任务都变得更新颖复杂，难度也逐渐增加。

设计与分析：

(这里主要挑了一些重点，及对笔者而言难度较大及体会深刻的题目)

1. PTA题目集题目小结：

　　①题目集四——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"，

 

输出格式:

 

见题目描述。

这里笔者先给出自己的源码：

import java.util.Scanner;

public class Main {
    

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner in = new Scanner(System.in);
        String s = in.nextLine();    
        
//        选项+":"+坐标x+","+坐标y+" "+坐标x+","+坐标y
        //输入的选项
        int choice = Integer.parseInt(s.substring(0, 1));
        if(!(choice >= 1 && choice <= 5))
        {
            System.out.print("Wrong Format");
            System.exit(0);
            
        }
        
        //判断有无':',并位置有无错误。
        if(s.charAt(1)!=':')
        {
            System.out.print("Wrong Format");
            System.exit(0);
        }
        int bool1 = s.indexOf(':',2);
        if(bool1 != -1)
        {
            System.out.print("Wrong Format");
            System.exit(0);
        }
            
        switch(choice)
        {
        case 1://计算斜率
        {
            int index_char = s.indexOf(':');
            int index_x1 = s.indexOf(',');
            int index_x2 = s.indexOf(',', index_x1+1);
            int index_null1 = s.indexOf(" ");
            
            //判断0是否在首位
            for(int i = 0; i<s.length(); i++)
            {
                if(s.charAt(i) == '0')
                {
                    if(i<s.length()-2)
                    {
                        if(s.charAt(i+1)=='0')
                        {
                            System.out.print("Wrong Format"); 
                            System.exit(0);
                        }
                        
                        if(s.charAt(i+1)>'0' && s.charAt(i+1)<='9')
                        {
                            System.out.print("Wrong Format"); 
                            System.exit(0);
                        }
                    }
                }
            }
            
            //点的数量
            if(index_null1 == -1)
            {
                 System.out.print("Wrong Format"); 
                 System.exit(0);
            }
            int index_null2 = s.indexOf(" ", index_null1+1);
            if(index_null2 !=-1)
            {
                System.out.println("wrong number of points");
                System.exit(0);
            }
            
            //判断逗号数量是否不对
            int sum_char = 0;
            for(int i = 1; i<s.length(); i++)
            {
                if(s.charAt(i) == ',')
                    sum_char ++;
            }
            if(sum_char != 2 )
            {
                 System.out.print("Wrong Format"); 
                 System.exit(0);
            }
            if(s.indexOf(',', index_null1) == -1)
            {
                System.out.print("Wrong Format"); 
                System.exit(0);
            }
            
    
            double x1 = Double.parseDouble(s.substring(index_char+1, index_x1));
            double y1 = Double.parseDouble(s.substring(index_x1+1, index_null1));
            double x2 = Double.parseDouble(s.substring(index_null1+1, index_x2));
            double y2 = Double.parseDouble(s.substring(index_x2+1, s.length()));
            
            if(x1 == x2 && y1 == y2)
            {
                System.out.println("points coincide");
                System.exit(0);
            }
            
            if(x1 == x2)
            {
                System.out.println("Slope does not exist");
                System.exit(0);
            }
            double k = (y1-y2)/(x1-x2);
            System.out.print(k); 
        }break;
        
        case 2://求一点到一直线的垂直距离
        {
            int index_char = s.indexOf(':');
            int index_x1 = s.indexOf(',');
            int index_x2 = s.indexOf(',', index_x1+1);
            int index_x3 = s.indexOf(',', index_x2+1);
            int index_null1 = s.indexOf(" ");
            int index_null2 = s.indexOf(" ", index_null1+1);
            
            //判断0是否在首位
            for(int i = 0; i<s.length(); i++)
            {
                if(s.charAt(i) == '0')
                {
                    if(i<s.length()-2)
                    {
                        if(s.charAt(i+1)=='0')
                        {
                            System.out.print("Wrong Format"); 
                            System.exit(0);
                        }
                        
                        if(s.charAt(i+1)>'0' && s.charAt(i+1)<='9')
                        {
                            System.out.print("Wrong Format"); 
                            System.exit(0);
                        }
                    }
                }
            }
            
            //点的数量
            if(index_null1 == -1 || index_null2 == -1)
            {
                System.out.println("wrong number of points");
                System.exit(0);
            }
            int index_null3 = s.indexOf(" ", index_null2+1);
            if(index_null3 !=-1)
            {
                System.out.println("wrong number of points");
                System.exit(0);
            }
            
            //判断逗号数量是否不对
            int sum_char = 0;
            for(int i = 1; i<s.length(); i++)
            {
                if(s.charAt(i) == ',')
                    sum_char ++;
            }
            if(sum_char != 3 )
            {
                 System.out.print("Wrong Format"); 
                 System.exit(0);
            }
            if(s.indexOf(',', index_null1) == -1)
            {
                System.out.print("Wrong Format"); 
                System.exit(0);
            }
            if(s.indexOf(',', index_null2) == -1)
            {
                System.out.print("Wrong Format"); 
                System.exit(0);
            }
            
            
            double x1 = Double.parseDouble(s.substring(index_char+1, index_x1));
            double y1 = Double.parseDouble(s.substring(index_x1+1, index_null1));
            double x2 = Double.parseDouble(s.substring(index_null1+1, index_x2));
            double y2 = Double.parseDouble(s.substring(index_x2+1, index_null2));
            double x3 = Double.parseDouble(s.substring(index_null2+1, index_x3));
            double y3 = Double.parseDouble(s.substring(index_x3+1, s.length()));
            
//             if(x1 == x2 && y1 == y2)
//             {
//                 System.out.println("points coincide");
//                 System.exit(0);
//             }
//             if(x1 == x3 && y1 == y3)
//             {
//                 System.out.println("points coincide");
//                 System.exit(0);
//             }
            if(x2 == x3 && y2 == y3)
            {
                System.out.println("points coincide");
                System.exit(0);
            }
            
            double k1 = (y2-y1)/(x2-x1);
            double k2 = (y3-y2)/(x3-x2);
            
            if(k1 == k2)
            {
                System.out.print("0.0");
                System.exit(0);
            }
            else
            {
                double a = Math.sqrt((Math.pow((x1-x2), 2) + Math.pow((y1-y2), 2)));
                double b = Math.sqrt((Math.pow((x1-x3), 2) + Math.pow((y1-y3), 2)));
                double c = Math.sqrt((Math.pow((x2-x3), 2) + Math.pow((y2-y3), 2)));
                double p = (a+b+c)/2;
                double area = Math.sqrt(p*(p-a)*(p-b)*(p-c));//海伦公式
                double distance = 2*area/c;
                System.out.printf("%.1f",distance);
            }
            
        }break;
        
        case 3://判断三点是否在同一条直线上
        {
            int index_char = s.indexOf(':');
            int index_x1 = s.indexOf(',');
            int index_x2 = s.indexOf(',', index_x1+1);
            int index_x3 = s.indexOf(',', index_x2+1);
            int index_null1 = s.indexOf(" ");
            int index_null2 = s.indexOf(" ", index_null1+1);
            
            //判断0是否在首位
            for(int i = 0; i<s.length(); i++)
            {
                if(s.charAt(i) == '0')
                {
                    if(i<s.length()-2)
                    {
                        if(s.charAt(i+1)=='0')
                        {
                            System.out.print("Wrong Format"); 
                            System.exit(0);
                        }
                        
                        if(s.charAt(i+1)>'0' && s.charAt(i+1)<='9')
                        {
                            System.out.print("Wrong Format"); 
                            System.exit(0);
                        }
                    }
                }
            }
            
            if(index_null1 == -1 || index_null2 == -1)
            {
                System.out.print("Wrong Format"); 
                            System.exit(0);
            }
            int index_null3 = s.indexOf(" ", index_null2+1);
            if(index_null3 !=-1)
            {
                System.out.println("wrong number of points");
                System.exit(0);
            }
            
            //判断逗号数量是否不对
            int sum_char = 0;
            for(int i = 1; i<s.length(); i++)
            {
                if(s.charAt(i) == ',')
                    sum_char ++;
            }
            if(sum_char != 3 )
            {
                 System.out.print("Wrong Format"); 
                 System.exit(0);
            }
            if(s.indexOf(',', index_null1) == -1)
            {
                System.out.print("Wrong Format"); 
                System.exit(0);
            }
            if(s.indexOf(',', index_null2) == -1)
            {
                System.out.print("Wrong Format"); 
                System.exit(0);
            }
            
            
            
            double x1 = Double.parseDouble(s.substring(index_char+1, index_x1));
            double y1 = Double.parseDouble(s.substring(index_x1+1, index_null1));
            double x2 = Double.parseDouble(s.substring(index_null1+1, index_x2));
            double y2 = Double.parseDouble(s.substring(index_x2+1, index_null2));
            double x3 = Double.parseDouble(s.substring(index_null2+1, index_x3));
            double y3 = Double.parseDouble(s.substring(index_x3+1, s.length()));
            
            
            if(x1 == x2 && y1 == y2)
            {
                System.out.println("points coincide");
                System.exit(0);
            }
            if(x1 == x3 && y1 == y3)
            {
                System.out.println("points coincide");
                System.exit(0);
            }
            if(x2 == x3 && y2 == y3)
            {
                System.out.println("points coincide");
                System.exit(0);
            }
            
            double k1 = (y2-y1)/(x2-x1);
            double k2 = (y3-y2)/(x3-x2);
            
            if(k1 == k2)
            {
                System.out.print("true");
                System.exit(0);
            }
            else
            {
                System.out.print("false");
                System.exit(0);
            }
            
        }break;
        
        case 4://判断两条直线是否平行
        {
            int index_char = s.indexOf(':');
            int index_x1 = s.indexOf(',');
            int index_x2 = s.indexOf(',', index_x1+1);
            int index_x3 = s.indexOf(',', index_x2+1);
            int index_x4 = s.indexOf(',', index_x3+1);
            int index_null1 = s.indexOf(" ");
            int index_null2 = s.indexOf(" ", index_null1+1);
            int index_null3 = s.indexOf(" ", index_null2+1);
            
            //判断0是否在首位
            for(int i = 0; i<s.length(); i++)
            {
                if(s.charAt(i) == '0')
                {
                    if(i<s.length()-2)
                    {
                        if(s.charAt(i+1)=='0')
                        {
                            System.out.print("Wrong Format"); 
                            System.exit(0);
                        }
                        
                        if(s.charAt(i+1)>'0' && s.charAt(i+1)<='9')
                        {
                            System.out.print("Wrong Format"); 
                            System.exit(0);
                        }
                    }
                }
            }
            
            if(index_null1 == -1 || index_null2 == -1 || index_null3 == -1)
            {
                System.out.print("Wrong Format"); 
                System.exit(0);
            }
            
            //判断逗号数量是否不对
            int sum_char = 0;
            for(int i = 1; i<s.length(); i++)
            {
                if(s.charAt(i) == ',')
                    sum_char ++;
            }
            if(sum_char != 4 )
            {
                 System.out.print("Wrong Format"); 
                 System.exit(0);
            }
            if(s.indexOf(',', index_null1) == -1)
            {
                System.out.print("Wrong Format"); 
                System.exit(0);
            }
            if(s.indexOf(',', index_null2) == -1)
            {
                System.out.print("Wrong Format"); 
                System.exit(0);
            }
            if(s.indexOf(',', index_null3) == -1)
            {
                System.out.print("Wrong Format"); 
                System.exit(0);
            }
            
            
        double x1 = Double.parseDouble(s.substring(index_char+1, index_x1));
            double y1 = Double.parseDouble(s.substring(index_x1+1, index_null1));
            double x2 = Double.parseDouble(s.substring(index_null1+1, index_x2));
            double y2 = Double.parseDouble(s.substring(index_x2+1, index_null2));
            double x3 = Double.parseDouble(s.substring(index_null2+1, index_x3));
            double y3 = Double.parseDouble(s.substring(index_x3+1, index_null3));
            double x4 = Double.parseDouble(s.substring(index_null3+1, index_x4));
            double y4 = Double.parseDouble(s.substring(index_x4+1, s.length()));
            
            if(x1 == x2 && y1 == y2)
            {
                System.out.println("points coincide");
                System.exit(0);
            }
            if(x3 == x4 && y3 == y4)
            {
                System.out.println("points coincide");
                System.exit(0);
            }
            
            //斜率不存在
            if(x1 == x2)
            {
                if(x3 == x4)
                {
                    System.out.print("true");
                    System.exit(0);
                }
                else
                {
                    System.out.print("false");
                    System.exit(0);
                }
            }
            else if(x3 == x4)
            {
                if(x1 == x2)
                {
                    System.out.print("true");
                    System.exit(0);
                }
                else
                {
                    System.out.print("false");
                    System.exit(0);
                }
            }
            else//斜率存在
            {
                double k1 = (y2-y1)/(x2-x1);
                double k2 = (y4-y3)/(x4-x3);
                
                if(k1 == k2)
                {
                    System.out.print("true");
                    System.exit(0);
                }
                else
                {
                    System.out.print("false");
                    System.exit(0);
                }
            }
            
        }break;
        
        case 5://求交点坐标
        {
            int index_char = s.indexOf(':');
            int index_x1 = s.indexOf(',');
            int index_x2 = s.indexOf(',', index_x1+1);
            int index_x3 = s.indexOf(',', index_x2+1);
            int index_x4 = s.indexOf(',', index_x3+1);
            int index_null1 = s.indexOf(" ");
            int index_null2 = s.indexOf(" ", index_null1+1);
            int index_null3 = s.indexOf(" ", index_null2+1);
            
            //判断0是否在首位
            for(int i = 0; i<s.length(); i++)
            {
                if(s.charAt(i) == '0')
                {
                    if(i<s.length()-2)
                    {
                        if(s.charAt(i+1)=='0')
                        {
                            System.out.print("Wrong Format"); 
                            System.exit(0);
                        }
                        
                        if(s.charAt(i+1)>'0' && s.charAt(i+1)<='9')
                        {
                            System.out.print("Wrong Format"); 
                            System.exit(0);
                        }
                    }
                }
            }
            
            if(index_null1 == -1 || index_null2 == -1 || index_null3 == -1)
            {
                System.out.print("Wrong Format"); 
                System.exit(0);
            }
            int index_null4 = s.indexOf(" ", index_null3+1);
            if(index_null4 !=-1)
            {
                System.out.println("wrong number of points");
                System.exit(0);
            }
            
            //判断逗号数量是否不对
            int sum_char = 0;
            for(int i = 1; i<s.length(); i++)
            {
                if(s.charAt(i) == ',')
                    sum_char ++;
            }
            if(sum_char != 4 )
            {
                 System.out.print("Wrong Format"); 
                 System.exit(0);
            }
            if(s.indexOf(',', index_null1) == -1)
            {
                System.out.print("Wrong Format"); 
                System.exit(0);
            }
            if(s.indexOf(',', index_null2) == -1)
            {
                System.out.print("Wrong Format"); 
                System.exit(0);
            }
            if(s.indexOf(',', index_null3) == -1)
            {
                System.out.print("Wrong Format"); 
                System.exit(0);
            }
            
            
            
            float x1 = Float.parseFloat(s.substring(index_char+1, index_x1));
            float y1 = Float.parseFloat(s.substring(index_x1+1, index_null1));
            float x2 = Float.parseFloat(s.substring(index_null1+1, index_x2));
            float y2 = Float.parseFloat(s.substring(index_x2+1, index_null2));
            float x3 = Float.parseFloat(s.substring(index_null2+1, index_x3));
            float y3 = Float.parseFloat(s.substring(index_x3+1, index_null3));
            float x4 = Float.parseFloat(s.substring(index_null3+1, index_x4));
            float y4 = Float.parseFloat(s.substring(index_x4+1, s.length()));
            
            if(x1 == x2 && y1 == y2)
            {
                System.out.println("points coincide");
                System.exit(0);
            }
            if(x3 == x4 && y3 == y4)
            {
                System.out.println("points coincide");
                System.exit(0);
            }
            
            
            //斜率不存在
            if(x1 == x2)
            {
                if(x3 == x4)
                {
                    System.out.print("is parallel lines,have no intersection point");
                    System.exit(0);
                }
                else
                {
                    float k2 = (y3-y4)/(x3-x4);
                    float b2 = (x3*y4-x4*y3)/(x3-x4);
                    
                    float x = x1;
                    float y = k2*x + b2;
                    float min = x3;
                    if(min > x4)
                    {
                        min = x4;
                    }
                    if(min > x1)
                    {
                        min = x1;
                    }
                    
                    float max = x3;
                    if(max < x4)
                    {
                        max = x4;
                    }
                    if(max < x1)
                    {
                        max = x1;
                    }
                    
                    if(x>min && x<max)
                    {
                        System.out.print(x+","+y+" "+"true");
                        System.exit(0);
                    }
                    else
                    {
                        System.out.print(x+","+y+" "+"false");
                        System.exit(0);
                    }
                    
                }
            }
            else if(x3 == x4)
            {
                if(x1 == x2)
                {
                    System.out.print("is parallel lines,have no intersection point");
                    System.exit(0);
                }
                else
                {
                    float k1 = (y1-y2)/(x1-x2);
                    float b1 = (x1*y2-x2*y1)/(x1-x2);

                    
                    float x = x3;
                    float y = k1*x + b1;
                    float min = x1;
                    if(min > x2)
                    {
                        min = x2;
                    }
                    if(min > x3)
                    {
                        min = x3;
                    }
                    
                    float max = x1;
                    if(max < x2)
                    {
                        max = x2;
                    }
                    if(max < x3)
                    {
                        max = x3;
                    }
                    
                    if(x>min && x<max)
                    {
                        System.out.print(x+","+y+" "+"true");
                        System.exit(0);
                    }
                    else
                    {
                        System.out.print(x+","+y+" "+"false");
                        System.exit(0);
                    }
                    
                }
            }
            else//斜率存在
            {
                float k1 = (y1-y2)/(x1-x2);
                float b1 = (x1*y2-x2*y1)/(x1-x2);
                float k2 = (y3-y4)/(x3-x4);
                float b2 = (x3*y4-x4*y3)/(x3-x4);
                
                
                if(k1==k2)
                {
                    System.out.print("is parallel lines,have no intersection point");
                    System.exit(0);
                }
                float x = (b2-b1)/(k1-k2);
                float y = (b2-b1)/(k1-k2)*k1 + b1;
                float min1 = x1;
                float min2 = x3;
                if(min1 > x2)
                {
                    min1 = x2;
                }
                if(min2 > x4)
                {
                    min2 = x4;
                }
                float min = min1;
                if(min > min2)
                {
                    min = min2;
                }
                
                float max1 = x1;
                float max2 = x3;
                if(max1 < x2)
                {
                    max1 = x2;
                }
                if(max2 < x4)
                {
                    max2 = x4;
                }
                float max = max1;
                if(max < max2)
                {
                    max = max2;
                }
                    
                
                if(x>min && x<max)
                {
                    System.out.print(x+","+y+" "+"true");
                    System.exit(0);
                }
                else
                {
                    System.out.print(x+","+y+" "+"false");
                    System.exit(0);
                }
                
        }
            
        }break;
        default:
        {
            System.out.print("Wrong Format");
            System.exit(0);
        }
        }
        

    }

}

题目分析：题目的要求是比较直接的（只要按照题目的要求写过去，拿个30多分是没有问题的），笔者认为，主要难点有两个：i：信息的输入问题，如何从输入中得到

需要的信息及判断输入格式是否错误(这里笔者了解的有两个方向，正则表达式和字符串操作)，这一点大家按照自己第一题的写法去写是没有什么大问题的。 ii：格式输

入错误的测试点，不知道大家是不是和笔者一样，将题目所有要求的代码实现了，题目所给的测试用例都通过了，但就是有一两个格式错误的测试点不能通过。可以这样说，

笔者在这题写代码花了半天，改bug卡了两天。最终，是因为一次偶然的机会，随便输入的一个样例测试（1： -3 ,01 -1,+1）发现结果不是输出wrong format，于是根据这个样例修改代码，

终于拿到了满分。

 

代码思路分析：这里笔者对正则表达式还不太熟练，因此对像这样类似的输入一整行数据，笔者是通过字符串操作切割提取出需要的的选项及坐标信息，进行一系列

的计算及操作。因此，按这种想法，思路是比较直接的（直接按题目要求一步一步写过去即可)，写起来比较简单，但是代码重复很多，很多代码基本上都是复制前面

写好的代码粘贴过来的。也有很大一部分原因是笔者比较懒，不想将专门判断输入格式，及获取坐标信息的代码单独提出来专门做一个类或者方法，这样的话至少能

减少三百行代码。

 

踩坑心得：由于这题其实题目想法比较简单，只要耐着性子一步一步写过去其实都没有什么大问题的，所以笔者其实没有碰到什么很大的坑，唯一想说的就是，大家

写代码时可以多运用自己曾经学过的知识（尤其是数学），这样可以扩展你的思路。

例如：题目要求的第二点，如何求得点到直线的距离呢？

 

 

 

 这里笔者刚开始的想法是用点到直线的距离公式，但再想一下发现不对，这样求直线的公式太麻烦了，再转念一想，求点到直线的距离不就是求这个点到已知线段

组成的三角形的高吗？三角形的高不就是面积的两倍除以这条已知线段的长度吗？已知线段的长度是非常好求的，那三角形的面积呢？笔者刚开始脑海中闪过的就是

初中学过的海伦公式，于是说干就干，这样，第二点就什么障碍都没了。

 

 

改进建议：就像笔者前面分析说的，如果将专门判断输入格式，及获取坐标信息的代码单独提出来专门做一个类或者方法，可以大大地减少代码。

int index_char = s.indexOf(':');
            int index_x1 = s.indexOf(',');
             int index_x2 = s.indexOf(',', index_x1+1);
            int index_x3 = s.indexOf(',', index_x2+1);
             int index_null1 = s.indexOf(" ");
             int index_null2 = s.indexOf(" ", index_null1+1);
            
            //判断0是否在首位
            for(int i = 0; i<s.length(); i++)
             {
                 if(s.charAt(i) == '0')
                 {
                     if(i<s.length()-2)
                     {
                         if(s.charAt(i+1)=='0')
                         {
                             System.out.print("Wrong Format"); 
                             System.exit(0);
                         }
                         
                         if(s.charAt(i+1)>'0' && s.charAt(i+1)<='9')
                         {
                             System.out.print("Wrong Format"); 
                             System.exit(0);
                         }
                     }
                 }
             }
             
             //点的数量
             if(index_null1 == -1 || index_null2 == -1)
             {
                 System.out.println("wrong number of points");
                 System.exit(0);
             }
             int index_null3 = s.indexOf(" ", index_null2+1);
             if(index_null3 !=-1)
             {
                 System.out.println("wrong number of points");
                 System.exit(0);
             }
             
             //判断逗号数量是否不对
             int sum_char = 0;
             for(int i = 1; i<s.length(); i++)
             {
                 if(s.charAt(i) == ',')
                     sum_char ++;
             }
             if(sum_char != 3 )
             {
                  System.out.print("Wrong Format"); 
                  System.exit(0);
             }
             if(s.indexOf(',', index_null1) == -1)
             {
                 System.out.print("Wrong Format"); 
                 System.exit(0);
             }
             if(s.indexOf(',', index_null2) == -1)
             {
                 System.out.print("Wrong Format"); 
                 System.exit(0);
             }
             
             
             double x1 = Double.parseDouble(s.substring(index_char+1, index_x1));
             double y1 = Double.parseDouble(s.substring(index_x1+1, index_null1));
             double x2 = Double.parseDouble(s.substring(index_null1+1, index_x2));
             double y2 = Double.parseDouble(s.substring(index_x2+1, index_null2));
             double x3 = Double.parseDouble(s.substring(index_null2+1, index_x3));
             double y3 = Double.parseDouble(s.substring(index_x3+1, s.length()));

 

还有一点，就是判断输入格式是否错误的时候可以用正则表达式，这样可以强制输入必须是正确匹配的，不是直接输出wrong format，这样也可以

节省很多功夫。

 

　　②题目集六——7-3（银行类业务设计）

　　　题目：

编写一个银行业务类BankBusiness，具有以下属性和方法：
（1）公有、静态的属性：银行名称bankName，初始值为“中国银行”。
（2）私有属性：账户名name、密码password、账户余额balance。
（3）银行对用户到来的欢迎（welcome）动作（静态、公有方法），显示“中国银行欢迎您的到来！”，其中“中国银行”自动使用bankName的值。
（4）银行对用户离开的提醒（welcomeNext）动作（静态、公有方法），显示“请收好您的证件和物品，欢迎您下次光临！”
（5）带参数的构造方法，完成开户操作。需要账户名name、密码password信息，同时让账户余额为0。
（6）用户的存款（deposit）操作（公有方法，需要密码和交易额信息），密码不对时无法存款且提示“您的密码错误！”；密码正确、完成用户存款操作后，要提示用户的账户余额，例如“您的余额有1000.0元。”。
（7）用户的取款（withdraw）操作（公有方法，需要密码和交易额信息）。密码不对时无法取款且提示“您的密码错误！”；密码正确但余额不足时提示“您的余额不足！”；密码正确且余额充足时扣除交易额并提示用户的账户余额，例如“请取走钞票，您的余额还有500.0元。”。

编写一个测试类Main，在main方法中，先后执行以下操作：
（1）调用BankBusiness类的welcome()方法。
（2）接收键盘输入的用户名、密码信息作为参数，调用BankBusiness类带参数的构造方法，从而创建一个BankBusiness类的对象account。
（3）调用account的存款方法，输入正确的密码，存入若干元。密码及存款金额从键盘输入。
（4）调用account的取款方法，输入错误的密码，试图取款若干元。密码及取款金额从键盘输入。
（5）调用account的取款方法，输入正确的密码，试图取款若干元（取款金额大于余额）。密码及取款金额从键盘输入。
（6）调用account的取款方法，输入正确的密码，试图取款若干元（取款金额小于余额）。密码及取款金额从键盘输入。
（7）调用BankBusiness类的welcomeNext()方法。

输入格式:

输入开户需要的姓名、密码
输入正确密码、存款金额
输入错误密码、取款金额
输入正确密码、大于余额的取款金额
输入正确密码、小于余额的取款金额

输出格式:

中国银行（银行名称）欢迎您的到来！
您的余额有多少元。
您的密码错误！
您的余额不足！
请取走钞票，您的余额还有多少元。
请收好您的证件和物品，欢迎您下次光临！

 

 这里笔者先给出自己的源码：

import java.util.Scanner;

class BankBusiness{
    public static String bankname = "中国银行";
    private String name;
    private int password;
    private    double balance = 0;
    
    
    public BankBusiness() {
        super();
        // TODO Auto-generated constructor stub
    }

    public void welcome() {//欢迎
        System.out.println(bankname + "欢迎您的到来！");
    }
    
    public void welcomeNext() {//送客
        System.out.println("请收好您的证件和物品，欢迎您下次光临！");
    }

    public BankBusiness(String name, int password) {
        super();
        this.name = name;
        this.password = password;
    }
    
    public void deposit(int password,int sum_money) {//存款
        if(password != this.password) {
            System.out.println("您的密码错误！");
        }
        else
        {
            this.balance += sum_money;
            System.out.println("您的余额有" + this.balance + "元。");
        }
    }
    
    public void withdraw(int password,int sum_money) {//取款
        if(password != this.password) {
            System.out.println("您的密码错误！");
        }
        else {
            if(sum_money > this.balance) {
                System.out.println("您的余额不足！");
            }
            else {
                this.balance -= sum_money;
                System.out.println("请取走钞票，您的余额还有" + this.balance + "元。");
            }
        }
    }
    
    
    
}
public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner in = new Scanner(System.in);
        BankBusiness account = new BankBusiness();
        account.welcome();
        String name_input = in.next();
        int password_input = in.nextInt();
        account = new BankBusiness(name_input, password_input);
        
        account.deposit(in.nextInt(), in.nextInt());
        account.withdraw(in.nextInt(), in.nextInt());
        account.withdraw(in.nextInt(), in.nextInt());
        account.withdraw(in.nextInt(), in.nextInt());
        account.welcomeNext();

    }

}

 

 代码设计：

 

 题目分析：相较于上次做的ATM类模拟系统，这一题，就显得简单多了，不过这里是通过类的设计实现的，也算是贴近我们

这门课程的学习内容吧。题目给的信息和提示很多，甚至连main方法的步骤都写出来了，所以这题难度不大，也是按照题目

提示一步一步写即可。

 

踩坑心得：

①：注意区分中英文，保险起见最好直接复制题目要的输出粘贴到代码上：

　

 

 这里题目要求输出的感叹号其实都是中文的，可笔者想当然的认为都是英文的，所以后面改的时候出现了很多不必要的麻烦，

因此，为了减去不必要的麻烦，建议大家写输出结果的时候直接将题目给的粘贴过去即可。

②：没有必要的方法不要创建，培养良好的习惯。

这个在后面的期中考试分析部分会深刻的体现出来。

　　2、链表练习：　

　　　（很惭愧，笔者的双向链表其实是不符合老师要求的，为避免误人子弟，这里就给出笔者单向链表的内容）　

　　题目：

使用Java实现链表功能，具体功能如下（参考）：

public interface LinearListInterface <E>{

        public boolean isEmpty();

public int getSize();

public E get(int index);

public void remove(int index);

public void add(int index, E theElement);

        public void add(E  element);

public void printList();    

}

结构如下：

//LinkedList class

public class LList<E>{

private Node<E> head,curr,tail;//头结点（非第一个节点），当前节点，尾节点

  private int size = 0;

}

 

//Node

public class Node<E>{

private E data;

private Node<E> next;

}

提交物：工程文件夹压缩文件,保证解压后可以直接import运行

 

笔者源码如下：

//单向链表
import java.util.Scanner;

//泛型接口(E)
interface LinearListInterface<E> {
    
    //判断链表数据是否为空
    public boolean isEmpty();
    
    //返回链表大小
    public int size();
    
    //返回链表指定下标的数据
    public E get(int index);
    
    //删除指定下标的信息
    public void remove(int index);
    
    //在指定下标处添加元素
    public void add(int index, E theElement);
    
    //在节点尾部添加元素
    public void add(E  element);
    
    //输出链表中的所有信息
    public void printList();    
}

//LinkedList class(链表类)
class LList<E> implements LinearListInterface<E>{
    private Node<E> head;
    private Node<E> tail;
    private Node<E> curr;
    private int size;
    
    public boolean isEmpty() {//判断链表数据是否为空
        if(this.tail == null) 
        {
            return false;
        }
        else
        {
            return true;
        }
    }
    
    public int size() { //返回链表大小
        return this.size;
    }
    
    public E get(int index) { //返回链表指定下标的数据
        int sign = 0;//sign:对照(指针):确定index对应链表的地址
        if(index>=0 && index<=size) 
        {
            this.curr = head;
            while(sign < index) {
                this.curr = this.curr.next;
                sign++;
            }
            return this.curr.o;//返回当前节点(sign = index)
        }
        else
        {
            return null;//输入下标超出链表可选范围
        }
    }
    
    public void remove(int index) {//删除指定下标的信息
        int sign = 0;
        if(index>=0 && index<=size) {
            if(sign == 0) {//目标为头部
                this.head = this.head.next;//头节点指向下一个
                this.size--;
            }
            else
            {
                this.curr = this.head;
                while(sign < index-1) {
                    this.curr = this.curr.next;
                    sign++;
                }
                this.curr.next = this.curr.next.next;
            }
            this.size--;
        }    
    }
    
    public void add(int index, E theElement) { //在指定下标处添加元素
        int count = 0;
        if(index>=0&&index<=this.size)
        {
            if(index==0)
            {
                this.head = new Node<E>(theElement,this.head);//如果添加在头部，theElement成为新头节点
            }
            else
            {
                this.curr = head;
                while(count<index-1)
                {//找到要添加信息的节点的位置
                    this.curr = this.curr.next;
                    count++;
                }
                this.curr.next = new Node<E>(theElement,this.curr.next);
            }
            this.size++;
        }
        
    }
    
    
    public void add(E element) {//在节点尾部添加元素
        Node<E> node =new Node<E>(element,null);//新节点    
        this.curr = this.tail;
        this.tail = node;
        if(curr==null) {
            head = node;
        }else{
            curr.next = node;
        }
        this.size++;
    }
    
    public void printList() {//输出链表中的所有信息
        for(int i = 0;i<this.size;i++) {
            System.out.print(get(i).toString()+" ");
        }
    }

}

//Node(节点类)
class Node<E>{
        public E o;//数据域
        public Node<E> next;//指针域
        public Node(E o,Node<E> next) {
            this.o = o;
            this.next = next;
        }
}


public class link {
    //主方法
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        
        LList<Integer> list = new LList<Integer>();//接口
        Scanner in = new Scanner(System.in);
        
        System.out.println("       < 简单示例 >    -->输入五个数据    ");
        for(int i = 0;i<5;i++) {
            list.add(in.nextInt());
        }
        System.out.println("所输入链表信息为:");
        list.printList();//输出输入的数据
        
        System.out.println("");
        System.out.println("选择你要执行的链表操作：");
        System.out.println("1.在指定下标添加节点信息");
        System.out.println("2.在尾部添加节点信息");
        System.out.println("3.退出");
        
        int choice = in.nextInt();
        while(true)
        {    
        switch(choice)
        {
        case 1:
            {
                System.out.println("请输入指定下标:");
                int index = in.nextInt();
                System.out.println("请输入需添加的整型数据：");
                int element = in.nextInt();
                list.add(index, element);
                System.out.println("\n增加第"+index+"节点后的链表:");
                list.printList();//输出链表
                
                System.out.println("");
                System.out.println("选择你要执行的链表操作：");
                System.out.println("1.在指定下标添加节点信息");
                System.out.println("2.在尾部添加节点信息");
                System.out.println("3.退出");
                choice = in.nextInt();
            }break;
        case 2:
            {
                System.out.println("请输入需添加的信息:");
                int index = in.nextInt();
                list.add(index);
                System.out.println("添加节点后的链表信息:");
                list.printList();//输出链表
                
                System.out.println("");
                System.out.println("选择你要执行的链表操作：");
                System.out.println("1.在指定下标添加节点信息");
                System.out.println("2.在尾部添加节点信息");
                System.out.println("3.退出");
                choice = in.nextInt();
            }break;
        case 3:
            {
                System.exit(0);
            }break;
        default: System.exit(0);
        }
        
        }
    }

　分析：笔者认为，相对于双向链表，单向链表比较直接，因为就像上学期c语言那样，只需关注一个next指针即可

，这样设计功能接口时思路也会比较清新，所以笔者比较适应单向链表。对于双向链表，笔者就会比较晕，不知道

怎么协调两个指针pre和next，当然，最后做是做出来的，但功能实现方面，肯定是没有完全符合老师给的要求的。

 

运行示例：

 

 

 心得：说到运行，笔者就想说一下main方法的事情，因为在双向链表互评的时候，笔者改的三人，有两个是没有写main函数的

可老师要求的是要可以运行调试，可你没main方法，你是怎么运行的呢，就确定写完之后就一定是对的吗？因此，建议大家做事一定

要做到尽善尽美，这样你开心，别人也舒服。

 

　　3、期中考试小结：

前言分析：这次期中考试题目不难，三题呈迭代进行，正如老师所说，上一题的源码可以直接复制到下一题使用，再进行修改即可。

第一题非常直接，笔者就不在这赘述了。

第二、三题：

源码：

import java.util.Scanner;

import javax.lang.model.element.Element;

public class Main {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        Point point1 = new Point();
        Point point2 = new Point();
        Plane plane = new Plane();
        double x1 = in.nextDouble();
        double y1 = in.nextDouble();
        double x2 = in.nextDouble();
        double y2 = in.nextDouble();

        if (x1 > 0 && x1 <= 200 && y1 > 0 && y1 <= 200 && x2 > 0 && x2 <= 200 && y2 > 0 && y2 <= 200) {
            point1.setX(x1);
            point1.setY(y1);
            point2.setX(x2);
            point2.setY(y2);
        } else {
            System.out.println("Wrong Format");
            System.exit(0);
        }
        String color = in.next();
        Line line = new Line(point1, point2, color);
        plane.setColor(color);

//        point1.display();
//        System.out.println("");
//        point2.display();
//        System.out.println("");
//        line.display();
//        System.out.println("");
//        plane.display();

//        Element element;
//        element = (Element) point1;// 起点Point
//        ((Point) element).display();
//
//        element = (Element) point2;// 终点Point
//        ((Point) element).display();
//
//        element = (Element) line;// 线段
//        ((Line) element).display();
//
//        element = (Element) plane;// 面
//        ((Plane) element).display();
        point1.display();
        System.out.println("");
        point2.display();
        System.out.println("");
        line.display();
        System.out.println("");
        plane.display();

    }

}

class Point extends Elememt {
    private double x;
    private double y;

    public Point() {
        super();
        // TODO Auto-generated constructor stub
    }

    public Point(double x, double y) {
        super();
        this.x = x;
        this.y = y;
    }

    public double getX() {
        return x;
    }

    public void setX(double x) {
        this.x = x;
    }

    public double getY() {
        return y;
    }

    public void setY(double y) {
        this.y = y;
    }

    public void display() {
        System.out.printf("(%.2f,%.2f)", this.x, this.y);
    }

}

class Line extends Elememt {
    private Point point1 = new Point();
    private Point point2 = new Point();
    private String color;

    public Line() {
        super();
        // TODO Auto-generated constructor stub
    }

    public Line(Point point1, Point point2, String color) {
        super();
        this.point1 = point1;
        this.point2 = point2;
        this.color = color;
    }

    public Point getPoint1() {
        return point1;
    }

    public void setPoint1(Point point1) {
        this.point1 = point1;
    }

    public Point getPoint2() {
        return point2;
    }

    public void setPoint2(Point point2) {
        this.point2 = point2;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public double getDistance() {
        double x = Math.pow((point1.getX() - point2.getX()), 2);
        double y = Math.pow((point1.getY() - point2.getY()), 2);
        return Math.sqrt(x + y);
    }

    public void display() {

        System.out.println("The line's color is:" + this.color);
        System.out.println("The line's begin point's Coordinate is:");
        point1.display();
        System.out.println("");
        System.out.println("The line's end point's Coordinate is:");
        point2.display();
        System.out.println("");
        System.out.printf("The line's length is:%.2f", this.getDistance());

    }
}

abstract class Elememt {
    public abstract void display();
}

class Plane extends Elememt {
    private String color;

    public Plane() {
        super();
        // TODO Auto-generated constructor stub
    }

    public Plane(String color) {
        super();
        this.color = color;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public void display() {
        System.out.println("The Plane's color is:" + this.color);
    }

}

 

首先，先给大家看个东西：

 

这是笔者写的代码的类图：

 

这是题目要求的类图：

 

 

怎么样，是不是没有对比没有伤害，/(ㄒoㄒ)/~~。

这也是笔者的心得之一：

一定一定要按要求写代码。

 也许现在有很多像笔者一样，对java还不太熟悉，上学期c语言也没学太好的人，认为这样很难，直接一点不行吗？但我们必须要按原则做事，

正如老师所说，我们是做工程的，做事一定要严谨，这是对我们自己的将来负责。

 

在期中考试之后，笔者又根据老师给的代码对自己的代码进行改进，功夫不负有心人，笔者终于成功了，为了不再赘述，这里笔者就只给出改进完之后的类图：

 

 看到是自己写的代码结构这么清晰（虽然借助了外力），笔者感到十分愉悦。

 

总结：

　　笔者认为，这几周最大的收获就是可以完全靠自己（不问同学，不网上参考）写题目，并且可以拿到不错的成绩，

这是我自进这个专业以来第一次有这样的感觉，就是好像可以自己做点事情，因为笔者其实对编程这方面没有很大的

兴趣，因此并没有在这方面花太多时间，直到这学期，我才顿悟，这是我的专业啊，所以我一定要认真学，把前面落下

的都补上来，尤其是期中考试的时候，我切实的感受到那种快感，在一个安静的环境下，独自一人完成这些题目，并拿到

属于自己能力应该拿到的分数，这种感觉让我非常愉悦。

　　但是，笔者也看到了自己还有很多不足之处，就比如说上面提到的类图的事，这让我明白我还有很多知识（如多态、

容器的常用类、面向对象的设计原则等）没有掌握，还有很多坏习惯还有待改正，这些也就是我下半段学期要做到事，

对此，我会不断努力，改进。

在这里笔者以自己的体悟建议大家，不要轻言放弃，现在还不会就加紧学，只要肯下功夫，一定可以突破自己的瓶颈。

 

对教学方面的改进建议：

　　没什么特别想说的，就是希望可以早点转换成线下教学，o(*￣▽￣*)ブ。