Blog作业2

第二阶段的学习结束了，接下来做个在总结吧。

前言：

　　1. PTA:本阶段完成了三次PTA的题目集，其中，最难的莫过于几何多边形的实现了。然后就是对正则表达式的考察，还有一个ATM机系统。最后完成了一次期中测验，主要是对多态的考察，难度不算大。

　　2. 学习通：完成了链表和双向链表的代码编写，难度适中，但是个人感觉完成度不是很完美。

　　3. 实验：主要是对农夫过河这个小游戏的完善迭代，也是对继承和多态的考察。

　　（注：为了排版方便和美观，接下来的代码都折叠了，可以点开查看！！！）

作业内容：

　　PTA：

　　　　1、正则表达式：这部分内容比较简单，靠的是自学。显示了解了正则表达从式匹配字符的机制。主要就是一组一组，一个圆括号（）为一组，然后就是一些表达式。

　　　　　　例如：[ ],+,-,\s等等的作用，还有类Pattern，Match的运用。不过一般可以不用调用，直接用字符串String有的方法 s.match(regex);就能够判断了。

import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Main {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        
        String qqNums = in.next();
        String regex = "^([1-9])([\\d]{4,14})$";
        Pattern p = Pattern.compile(regex);
        Matcher m = p.matcher(qqNums);
        
        if(m.find()) 
            System.out.println("你输入的QQ号验证成功");
        else 
            System.out.println("你输入的QQ号验证失败");
        
        in.close();
    }

}

　　　　　这里是其中一段检测qq号的。

　　　　2、多边形：

　　　　　　到这里我可太多要说得了！由于一开始看题目没有整题分析，导致后期的代码非常难写！最开始我是现有一些些简单的设计的，比如MCV模式如何运用到这题，但是弄巧成拙，对象的思想并没有太　　　　　　　　　　　　　　　　　　

　　　　深刻的理解，仅仅是简单的分为输入，处理，输出，中间的类，然后导致每一题都跟新题目一样！现在都没眼看那时候写的代码，不过还是放上去吧　　

import java.util.Scanner;
import java.util.ArrayList;
public class Main {

    public static void main(String[] args) {
        Intermediary inter = new Intermediary();
        inter.work();
    }
}

class Intermediary {
    ProcessData process = new ProcessData();
    Calculate calculate = new Calculate();
    Display display = new Display();
    
    public void work() {

        Scanner in = new Scanner(System.in);
        process.setcoordinates(in.nextLine());
        in.close();
        
        process.segMentation();
        if(process.dateValidity() && process.getNumbersOfComma() <= 5)
            process.transform();

        if(process.worngFormat() == 1) {
            calculate.setChoose(process.getChoose());
            calculate.setArr(process.getCoord());
            calculate.doing();
            process.setTriangle(calculate.isTriangle());

            display.setWrongFormat(process.worngFormat());
            display.setChoose(process.getChoose());
            display.setStr(calculate.getCoord());
        }else {
            display.setWrongFormat(process.worngFormat());
        }
        display.show();
    }
}

class ProcessData {
    
    private ArrayList<String> coordinate = new ArrayList<String>(); 
    private String coordinates;
    private int numbersOfBlank =0 , numbersOfComma = 0;
    private double [] coord = new double[11];
    private int choose;
    private boolean isTriangle = true;
    
    public void setTriangle(boolean isTriangle) {
        this.isTriangle = isTriangle;
    }

    public int getChoose() {
        return choose;
    }

    public int getNumbersOfComma() {
        return numbersOfComma;
    }

    public double[] getCoord() {
        return coord;
    }
    
    public void setcoordinates(String coordinates) {
        this.coordinates = coordinates;
    }
    
    public void transform() {
        int i = 0;
        for(String a : coordinate) {
            this.coord[i] = Double.parseDouble(a);
            i++;
        }
    }

    public boolean blankValidity() {
        if(this.numbersOfComma - 1 == this.numbersOfBlank)
            return true;
        return false;
    }
    
    public int worngFormat() {
        if(!this.dateValidity() && !this.blankValidity())
            return 0;
        else if(((choose == 1 || choose == 2 || choose == 3) && this.numbersOfComma != 3)||
                (choose == 4 && this.numbersOfComma != 5)||
                ( choose == 5 && this.numbersOfComma != 4)||
                this.numbersOfComma > 5) {
            return 2;
        } else if(choose == 4) {
            if(coord[1] == coord [3] && coord[2] == coord[4])
                return 4;
            if(!isTriangle)
                return 5;
        } else if(choose == 1 || choose == 2 || choose == 3) {
            if(!isTriangle)
                return 5;
        } return 1; 
    }
    
    public void segMentation() {
        int j = 0;
        for(int i = 0; i < coordinates.length(); i++) {
            if(coordinates.charAt(i) == ',') {
                coordinate.add(coordinates.substring(j, i));
                j = i + 1;
                numbersOfComma++;
            }
            
            if(coordinates.charAt(i) == ' ') {
                coordinate.add(coordinates.substring(j,i));
                j = i + 1;
                numbersOfBlank++;
            }
            if(coordinates.charAt(i) == ':') {
                coordinate.add(coordinates.substring(j,i));
                j = i + 1;
            }
        }
        coordinate.add(coordinates.substring(j,coordinates.length()));
        choose = Integer.parseInt(coordinates.substring(0, 1));
    }

    
    public boolean dateValidity() {
        if(this.choose >=1 && this.choose <=5) {
            String pattern = "[12345]\\:[\\+|-]?([0]|([1-9]((\\d)?)+))(\\.\\d+)?\\,([+\\-]?([0]|([1-9]((\\d)?)+)))(\\.\\d+)?(\\s([+\\-" + "]?([0]|([1-9]((\\d)?)+)))(\\.\\d+)?\\,([+\\-]?([0]|([1-9]((\\d)?)+)))(\\.\\d+)?)+";
            if(this.coordinates.matches(pattern)) {
                return true;
            }
        }
        return false;
    }

}

class Display {
    private int wrongFormat = 0,choose = 0;
    private String str = "";
    
    public void setChoose(int choose) {
        this.choose = choose;
    }

    public void setWrongFormat(int wrongFormat) {
        this.wrongFormat = wrongFormat;
    }
    
    public void setStr(String str) {
        this.str = str;
    }

    public void show() {
        if(this.wrongFormat == 0)
            System.out.println("Wrong Format");
        else if(this.wrongFormat == 2)
            System.out.println("wrong number of points");
        else if(this.wrongFormat == 4)
            System.out.println("points coincide");
        else if(this.wrongFormat == 5)
            System.out.println("data error");
        else if(this.wrongFormat == 1){
            if(choose == 1 || choose == 2 || choose == 3) 
                System.out.println(this.str);
            else if(choose == 4) {
                
            }else if(choose == 5) {
                System.out.println(str);
            }
        }
    }
}

class Calculate {
    private double[] arr;
    private int choose;
    String coord = "";
    
    public String getCoord() {
        return coord;
    }

    public void setChoose(int choose) {
        this.choose = choose;
    }
    
    public void setArr(double[] arr) {
        this.arr = arr;
    }
    
    public void doing() {
        if(this.choose == 1) {
            equilateralTriangle();
        } else if(this.choose == 2) {
            this.OptionTwo();
        } else if(this.choose == 3) {
            this.optionThree();
        } else if(this.choose == 4) {
        } else {
        }
    }

    private void optionThree() {
        double x,y,z;
        x = (arr[3]-arr[1])*(arr[5]-arr[1])+(arr[4]-arr[2])*(arr[6]-arr[2]);
        y = (arr[1]-arr[3])*(arr[5]-arr[3])+(arr[2]-arr[4])*(arr[6]-arr[4]);
        z = (arr[1]-arr[5])*(arr[3]-arr[5])+(arr[4]-arr[6])*(arr[2]-arr[6]);
        if(x==0 || y==0 || z==0) {
            coord = "false true false";
        }else if(x < 0 || y < 0 || z < 0) {
            coord = "true false false";
        }else if(x > 0 && y > 0 && z > 0) {
            coord = "false false true";
        }
    }
    
    public void equilateralTriangle() {
        double x,y,z;
        x = Math.sqrt(Math.pow((arr[1]-arr[3]),2) + Math.pow((arr[2]-arr[4]),2));
        y = Math.sqrt(Math.pow((arr[1]-arr[5]),2) + Math.pow((arr[2]-arr[6]),2));
        z = Math.sqrt(Math.pow((arr[3]-arr[5]),2) + Math.pow((arr[4]-arr[6]),2));
        if(x==y && x==z && y==z)
            coord = "true true";
        else if(x==y || x==z || y==z)
            coord = "true false";
        else coord = "false false";
    }
    
    public String transfer(double c) {
        String str_d = String.valueOf(c);
              str_d = str_d.substring(str_d.indexOf(".") + 1);
                int len = str_d.length();
                len = len > 6 ? 6 : len;
                 String area1 = String.format("%."+len+"f", c);
                 return area1;
    }
    
    public void OptionTwo() {
        double x,y,z,area,x1,y1;
        x = Math.sqrt(Math.pow((arr[1]-arr[3]),2) + Math.pow((arr[2]-arr[4]),2));
        y = Math.sqrt(Math.pow((arr[1]-arr[5]),2) + Math.pow((arr[2]-arr[6]),2));
        z = Math.sqrt(Math.pow((arr[3]-arr[5]),2) + Math.pow((arr[4]-arr[6]),2));
        area = Math.abs((arr[1] - arr[3])*(arr[2]-arr[6])-(arr[1]-arr[5])*(arr[2]-arr[4]))/2;
        x1 = (arr[1]+arr[3]+arr[5])/3;
        y1 = (arr[2]+arr[4]+arr[6])/3;
        if(this.isTriangle()){
            coord += transfer(x+y+z)+" "+transfer(area)+" "
                    +transfer(x1) +","+transfer(y1);
        }
    }

    public boolean isTriangle() {
        double len1,len2,len3;
        if(choose == 1 || choose == 2 || choose == 3) {
            len1=Math.sqrt((arr[1]-arr[3])*(arr[1]-arr[3])+((arr[2]-arr[4])*(arr[2]-arr[4])));
            len2=Math.sqrt((arr[1]-arr[5])*(arr[1]-arr[5])+((arr[2]-arr[6])*(arr[2]-arr[6])));
            len3=Math.sqrt((arr[3]-arr[5])*(arr[3]-arr[5])+((arr[6]-arr[4])*(arr[6]-arr[4])));
        } else {
            len1=Math.sqrt((arr[7]-arr[9])*(arr[7]-arr[9])+((arr[8]-arr[10])*(arr[8]-arr[10])));
            len2=Math.sqrt((arr[7]-arr[5])*(arr[7]-arr[5])+((arr[8]-arr[6])*(arr[8]-arr[6])));
            len3=Math.sqrt((arr[9]-arr[5])*(arr[9]-arr[5])+((arr[6]-arr[10])*(arr[6]-arr[10])));
        }
        if(Math.abs(len1+len2-len3) > 0.01 && 
                Math.abs(len3+len2-len1) > 0.01 && 
                Math.abs(len1+len3-len2) > 0.01) {
            return true;
        }else return false;
    }
}

　　　　PTA04-3：这是三角形的。写的真的丑，而且到最后实在不会写了，还没写完，浅看一下吧。。。

　　类图奉上：

 　　　　   然后老师发了他的类图，对比一下才发现原来应该这样写！

　　　　　然后我花了三个下午的时间，完成了PTA06-2：

　　　　　PTA06-2：

import java.util.ArrayList;
import java.util.Scanner;

////
public class Main {

    public static void main(String[] args) {
        InputData d = new InputData();
        Scanner input = new Scanner(System.in);

        String s = input.nextLine().trim();

        BasicType.isBasicType(s);

        ParseInput.parseInput(s, d);
        PointInputError.wrongNumberOfPoints(d.getPoints(), d.getChoice());
        if (d.getChoice() == 1 || d.getChoice() == 2 || d.getChoice() == 3)
            LineInputError.pointsCoincideError(d.getPoints().get(0), d.getPoints().get(1), d.getPoints().get(2),
                    d.getPoints().get(3));
        else if (d.getChoice() == 4)
            LineInputError.pointsCoincideError(d.getPoints().get(0), d.getPoints().get(1));

        if (d.getChoice() == 1)
            handle1(d.getPoints());
        else if (d.getChoice() == 2)
            handle2(d.getPoints());
        else if (d.getChoice() == 3)
            handle3(d.getPoints());
        else if (d.getChoice() == 4)
            handle4(d.getPoints());
        else if (d.getChoice() == 5)
            handle5(d.getPoints());

        input.close();

    }

    public static void handle1(ArrayList<Point> ps) {
        Quadrilateral q = new Quadrilateral(ps.get(0), ps.get(1), ps.get(2), ps.get(3));
        boolean bool = q.isQuadrangle() && q.isSuitableQuadrangle();
        System.out.println(bool + " " + q.isRhomboid());
    }

    public static void handle2(ArrayList<Point> ps) {
        Quadrilateral q = new Quadrilateral(ps.get(0), ps.get(1), ps.get(2), ps.get(3));
        if (q.isSuitableQuadrangle() && q.isQuadrangle()) {
            System.out.println(q.isRhombus() + " " + q.isRectangle() + " " + q.isSquare());
        } else {
            System.out.println("not a quadrilateral");
        }
    }

    public static void handle3(ArrayList<Point> ps) {
        Quadrilateral q = new Quadrilateral(ps.get(0), ps.get(1), ps.get(2), ps.get(3));
        if (q.isSuitableQuadrangle()&&q.isQuadrangle()) {
            System.out.println(q.isConvexQua() + " " + BasicType.transfer(q.getLengthOfSides()) + " " + BasicType.transfer(q.getArea()));
        } else {
            System.out.println("not a quadrilateral");
        }
    }

    public static void handle4(ArrayList<Point> ps) {
        Line l = new Line(ps.get(0), ps.get(1));
        Quadrilateral q = new Quadrilateral(ps.get(2), ps.get(3), ps.get(4), ps.get(5));
        if (q.isSuitableQuadrangle() && q.isQuadrangle()) {
            if (q.isCoincideLine(l)) {
                System.out.println("The line is coincide with one of the lines");
            } else {
                System.out.print(q.getIntersections(l).size());
                if(q.getIntersections(l).size() == 2) {
                    double [] a = q.calArea(q.getIntersections(l).get(0), q.getIntersections(l).get(1));
                    System.out.print(" " + BasicType.transfer(Math.min(a[0], a[1])) + " " + BasicType.transfer(Math.max(a[0], a[1])));
                }
            }
        } else if (q.isSuitableTriangle()) {
            Triangle t = q.removePoint();
            if (t.isLineCoincide(l)) {
                System.out.println("The line is coincide with one of the lines");
            } else {
                System.out.print(t.getIntersections(l).size());
                if (t.getIntersections(l).size() == 2) {
                    double [] a = t.calArea(t.getIntersections(l).get(0), t.getIntersections(l).get(1));
                    System.out.print(" " + BasicType.transfer(Math.min(a[0], a[1])) + " " + BasicType.transfer(Math.max(a[0], a[1])));
                }
            }
        } else {
            System.out.println("not a quadrilateral or triangle");
        }
    }
    
    public static void handle5(ArrayList<Point> ps) {
        Quadrilateral q = new Quadrilateral(ps.get(1), ps.get(2), ps.get(3), ps.get(4));
        if (q.isSuitableQuadrangle() && q.isConvexQua()) {
            if (q.isOnTheEdge(ps.get(0)) || q.isVertex(ps.get(0))) {
                System.out.println("on the quadrilateral");
            } else if (q.isInside(ps.get(0))) {
                System.out.println("in the quadrilateral");
            } else {
                System.out.println("outof the quadrilateral");
            }

        } else if (q.isSuitableTriangle()) {
            Triangle t = q.removePoint();
            if (t.isOnTheEdge(ps.get(0)) || t.isVertex(ps.get(0))) {
                System.out.println("on the triangle");
            } else if (t.isInside(ps.get(0))) {
                System.out.println("in the triangle");
            } else {
                System.out.println("outof the triangle");
            }
        } else {
            System.out.println("not a quadrilateral or triangle");
        }
    }
}

////////
class Point {
    private double x;
    private double y;

    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 boolean equal(Point p) {
        if (this.x == p.getX() && this.y == p.getY())
            return true;
        return false;
    }

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

////////
class Line {
    private Point a;
    private Point b;

    public Line(double x1, double y1, double x2, double y2) {
        super();
        a.setX(x1);
        a.setY(y1);
        b.setX(x2);
        b.setY(y2);
    }

    public Line(Point a, Point b) {
        super();
        this.a = a;
        this.b = b;
    }

    public Point getA() {
        return a;
    }

    public Point getB() {
        return b;
    }

    public boolean isHasSlope() {
        if (a.getX() == b.getX())
            return false;
        return true;
    }

    public double getSlope() {
        return (a.getY() - b.getY()) / (a.getX() - b.getX());
    }

    public static double getSlope(Point a, Point b) {
        return (a.getY() - b.getY()) / (a.getX() - b.getX());
    }

    public boolean isOnline(Point p) {
        if (isHasSlope()) {
            if (this.getSlope() == Line.getSlope(a, p) )
                return true;
            return false;
        } else {
            if (p.getX() == a.getX())
                return true;
            return false;
        }
    }


    public boolean isBetween(Point p) {
        if(this.isOnline(p)) {
            if ((p.getX() > Math.min(a.getX(), b.getX()) && p.getX() < Math.max(a.getX(), b.getX())) ||
                    (p.getY() > Math.min(a.getY(), b.getY()) && p.getY() < Math.max(a.getY(), b.getY())))
                return true;
            return false;
        }
        return false;
    }


    public Point getMiddlePoint() {
        return new Point((a.getX() + b.getX()) / 2, (a.getY() + b.getY()) / 2);
    }

    public double getAngle(Line line) {
        double cos;
        cos = ((a.getX()-b.getX())*(line.getA().getX()-line.getB().getX())+
                (a.getY()-b.getY())*(line.getA().getY()-line.getB().getY()))/
                a.getDistance(b)*line.getA().getDistance(line.getB());
        return Math.acos(cos);
        //方向为BA方向
    }
    
    public double getLengthOfSegment() {
        return Math.sqrt(Math.pow(a.getX()-b.getX(),2) + Math.pow(a.getY()-b.getY(),2));
    }
    
    public boolean isParallel(Line line) {
        if((!line.isHasSlope() && !this.isHasSlope())||
                (line.getSlope() == this.getSlope()))
            return true;
        return false;    
    }
    
    public boolean isCoincide(Line line) {
        if(line.isOnline(a) && line.isOnline(b))
            return true;
        return false;
    }
    
    public Point getIntersection(Line line) {
        double A1,B1,C1;
        A1 = b.getY()-a.getY();
        B1 = a.getX()-b.getX();
        C1 = b.getX()*a.getY()-a.getX()*b.getY();
        double A2,B2,C2;
        A2 = line.getB().getY()-line.getA().getY();
        B2 = line.getA().getX()-line.getB().getX();
        C2 = line.getB().getX()*line.getA().getY()-line.getA().getX()*line.getB().getY();
        double D,D1,D2;
        D = A1*B2-A2*B1;
        D1 = B1*C2-B2*C1;
        D2 = C1*A2-C2*A1;
        return new Point(D1/D,D2/D);
    }
    
    public double getDistancesOfPointToLine(Point p) {
        double A,B,C;
        A = b.getY()-a.getY();
        B = a.getX()-b.getX();
        C = b.getX()*a.getY()-a.getX()*b.getY();
        return Math.abs(A*p.getX() + B*p.getY() + C)/Math.sqrt(A*A + B*B);
    }
    public int getSideOfLine(Point p) {
        double A,B,C;
        A = b.getY()-a.getY();
        B = a.getX()-b.getX();
        C = b.getX()*a.getY()-a.getX()*b.getY();
        if(A*p.getX() + B*p.getY() + C > 0)
            return 1;
        else if(A*p.getX() + B*p.getY() + C == 0)
            return 0;
        else return -1;
    }
}

////////
class Triangle {
    private Point x, y, z;
    private Line xy,xz,yz;
    
    public Triangle(Point x, Point y, Point z) {
        super();
        this.x = x;
        this.y = y;
        this.z = z;
        this.xy = new Line(x,y);
        this.xz = new Line(x,z);
        this.yz = new Line(y,z);
    }

    public Point getX() {
        return x;
    }

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

    public Point getY() {
        return y;
    }

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

    public Point getZ() {
        return z;
    }

    public void setZ(Point z) {
        this.z = z;
    }

    public Line getXy() {
        return xy;
    }

    public Line getXz() {
        return xz;
    }

    public Line getYz() {
        return yz;
    }
    public boolean isTriangle() {
        
        if (!xy.isOnline(z))
            return true;
        return false;
    }

    public Point getMidpoint() {
        return null;
    }

    public Line[] getMidline() {
        Line[] lineList = new Line[3];
        lineList[0] = new Line(x,yz.getMiddlePoint());
        lineList[1] = new Line(y,xz.getMiddlePoint());
        lineList[2] = new Line(z,xy.getMiddlePoint());
        
        return lineList;
    }

    public Line[] getSideline() {
        Line[] lineList = new Line[3];
        lineList[0] = xy;
        lineList[1] = xz;
        lineList[2] = yz;
        return lineList;
    }

    public double getArea() {
        return Math.abs((x.getX()-y.getX())*(x.getY()-z.getY()) - 
                (x.getY()-y.getY())*(x.getX()-z.getX()))/2;
                
    }

    public double getPerimeter() {
        return 0;
    }

    public double[] getAngleS() {
        return null;
    }

    public boolean isIsoscelesTriangle() {//等腰
        return false;
    }

    public boolean isEquilateralTriangle() {//等边
        return false;
    }

    public boolean isRightTriangle() {//直角
        return false;
    }

    public boolean isObtuseTriangle() {//钝角
        return false;
    }

    public boolean isAcuteTriangle() {//锐角
        return false;
    }

    public boolean isVertex(Point p) { 
        if(p.equal(x) || p.equal(y) ||p.equal(z))
            return true;
        return false;
    }

    public boolean isInside(Point p) {
        Triangle t1,t2,t3;
        t1 = new Triangle(x,y,p);
        t2 = new Triangle(x,z,p);
        t3 = new Triangle(y,z,p);
        if(t1.getArea()+t2.getArea()+t3.getArea() > this.getArea())
            return false;
        return true;
    }

    public ArrayList<Point> getIntersections(Line line) {
        ArrayList<Point> list = new ArrayList<Point>();
        Point p1 = line.getIntersection(xy);
        Point p2 = line.getIntersection(xz);
        Point p3 = line.getIntersection(yz);
        if (this.isOnTheEdge(p1) || this.isVertex(p1)) {
            list.add(p1);
        }

        if (this.isOnTheEdge(p2) || this.isVertex(p2)) {
            if (!p2.equal(p1))
                list.add(p2);
        }

        if (this.isOnTheEdge(p3) || this.isVertex(p3)) {
            if (!p3.equal(p2) && !p3.equal(p1))
                list.add(p3);
        }

        return list;

    }

    public double[] calArea(Point p1, Point p2) {

        Line l = new Line(p1, p2);
        double[] a = new double[2];
        
        if (l.getSideOfLine(x) == l.getSideOfLine(y) || l.getSideOfLine(x) == 0 || l.getSideOfLine(y) == 0)
            a[0] = new Triangle(p1, p2, z).getArea();
        else if (l.getSideOfLine(x) == l.getSideOfLine(z) || l.getSideOfLine(x) == 0 || l.getSideOfLine(z) == 0)
            a[0] = new Triangle(p1, p2, y).getArea();
        else if (l.getSideOfLine(y) == l.getSideOfLine(z) || l.getSideOfLine(y) == 0 || l.getSideOfLine(z) == 0)
            a[0] = new Triangle(p1, p2, x).getArea();

        a[1] = this.getArea() - a[0];

        return a;
    }

    public double calAreaDiffrence(Triangle t1) {
        return 0;
    }

    public boolean isOnTheEdge(Point p) {
        if(xy.isBetween(p) || xz.isBetween(p) || yz.isBetween(p))
            return true;
        return false;
    }

    public boolean isLineCoincide(Line l) {
        if(l.isCoincide(xy) || l.isCoincide(xz) ||l.isCoincide(yz))
            return true;
        return false;
    }

}

////////
class Quadrilateral {
    private Point a, b, c, d;
    private Line ab, bc, cd, da;

    public Quadrilateral(Point a, Point b, Point c, Point d) {
        super();
        this.a = a;
        this.b = b;
        this.c = c;
        this.d = d;
        this.ab = new Line(a, b);
        this.bc = new Line(b, c);
        this.cd = new Line(c, d);
        this.da = new Line(d, a);
    }

    public double getLengthOfSides() {
        return ab.getLengthOfSegment() + bc.getLengthOfSegment() + 
                cd.getLengthOfSegment() + da.getLengthOfSegment();
    }
    
    public double getArea() {
        if(this.isConvexQua()) {
            Triangle t1 = new Triangle(a,b,c);
            Triangle t2 = new Triangle(a,d,c);
            return t1.getArea()+t2.getArea();
        }else {
            if(new Triangle(b,c,d).isInside(a) || new Triangle(b,a,d).isInside(c)) {
                Triangle t1 = new Triangle(a,b,c);
                Triangle t2 = new Triangle(a,d,c);
                return t1.getArea()+t2.getArea();
            }else if(new Triangle(a,c,d).isInside(b) || new Triangle(a,c,b).isInside(d)) {
                Triangle t1 = new Triangle(d,b,c);
                Triangle t2 = new Triangle(a,d,b);
                return t1.getArea()+t2.getArea();
            }return 0;
        }
    }
    
    public boolean isQuadrangle() {
        Triangle t = new Triangle(a, b, c);
        if(t.isTriangle()) {
            if (t.getXy().isOnline(d) || t.getXz().isOnline(d)|| t.getYz().isOnline(d))
                return false;
            return true;
        }return false;
    }
    
    public boolean isSuitableQuadrangle() {
        Point p1,p2;
        if(ab.isParallel(cd) && da.isParallel(bc))
            return true;
        else if(ab.isParallel(cd) && !da.isParallel(bc)) {
            p1 = da.getIntersection(bc);
            if(da.isBetween(p1) && bc.isBetween(p1))
                return false;
            return true;
        }
        else if(!ab.isParallel(cd) && da.isParallel(bc)) {
            p1 = ab.getIntersection(cd);
            if(ab.isBetween(p1) && cd.isBetween(p1))
                return false;
            return true;
        }
        else {
            p1 = ab.getIntersection(cd); 
            p2 = da.getIntersection(bc);
            if((ab.isBetween(p1) && cd.isBetween(p1))||(da.isBetween(p2) && bc.isBetween(p2)))
                return false;
            return true;
        }
    }
    
    public boolean isConvexQua() {
        Triangle t1 = new Triangle(b,c,d);
        Triangle t2 = new Triangle(a,c,d);
        Triangle t3 = new Triangle(a,b,d);
        Triangle t4 = new Triangle(a,b,c);
        if(t1.isInside(a) || t2.isInside(b) || t3.isInside(c) || t4.isInside(d))
            return false;
        return true;
            
    }

    public boolean isRhomboid() {
        if (this.isConvexQua()) {
            if (ab.isParallel(cd) && bc.isParallel(da))
                return true;
            return false;
        }
        return false;
    }

    public boolean isRhombus() {// 菱形
        if (this.isRhomboid()) {
            if (ab.getLengthOfSegment() == bc.getLengthOfSegment())
                return true;
            return false;
        }
        return false;
    }

    public boolean isRectangle() {
        if(this.isRhomboid()) {
            if(ab.getAngle(da) == Math.acos(0))
                return true;
            return false;
        }
        return false;
    }
    
    public boolean isSquare() {
        if(this.isRectangle() && this.isRhombus())
            return true;
        return false;
    }
    
    public boolean isCoincideLine(Line line) {
        if(line.isCoincide(ab) || line.isCoincide(bc) || line.isCoincide(cd) || line.isCoincide(da))
            return true;
        return false;
    }
    
    public boolean isSuitableTriangle() { 
        if(this.isTriangle()) {
            if(new Line(a,c).isBetween(d) || new Line(a,c).isBetween(b) ||
                    new Line(b,d).isBetween(a) || new Line(b,d).isBetween(c) ||
                    d.equal(a) || d.equal(c) ||
                    a.equal(b) || a.equal(d) ||
                    b.equal(a) || d.equal(c) ||
                    c.equal(b) || c.equal(d))
                return true;
        }
        return false;
    }
    
    public boolean isTriangle() {
        if(new Triangle(a,b,c).isOnTheEdge(d) || new Triangle(a,b,c).isVertex(d) ||
                new Triangle(a,b,d).isOnTheEdge(c) || new Triangle(a,b,d).isVertex(c)||
                new Triangle(a,d,c).isOnTheEdge(b) || new Triangle(a,d,c).isVertex(b)||
                new Triangle(b,d,c).isOnTheEdge(a) || new Triangle(b,d,c).isVertex(a))
            return true;
        return false;
    }
    
    public Triangle removePoint() {
        if(new Line(a,c).isBetween(d) || d.equal(a) || d.equal(c)) {
            return new Triangle(a,b,c);
        }
        if(new Line(a,c).isBetween(b) || b.equal(a) || b.equal(c)) {
            return new Triangle(a,d,c);
        }
        if(new Line(b,d).isBetween(a) || a.equal(b) || a.equal(d)) {
            return new Triangle(d,b,c);
        }
        if(new Line(b,d).isBetween(c) || c.equal(b) || c.equal(d)) {
            return new Triangle(a,b,d);
        }
        return null;
    }
    
    public boolean isOnTheEdge(Point p) {
        if(ab.isBetween(p) || bc.isBetween(p) || cd.isBetween(p) || da.isBetween(p))
            return true;
        return false;
    }
    
    public boolean isVertex(Point p) { 
        if(p.equal(a) || p.equal(b) || p.equal(c) || p.equal(d))
            return true;
        return false;
    }
    
    public boolean isInside(Point p) {
        if(new Triangle(a,b,c).isInside(p) || new Triangle(a,d,c).isInside(p) || new Line(a,c).isBetween(p))
            return true;
        return false;
    }
    public ArrayList<Point> getIntersections(Line line) {
        ArrayList<Point> list = new ArrayList<Point>();
        Point p1 = line.getIntersection(ab);
        Point p2 = line.getIntersection(bc);
        Point p3 = line.getIntersection(cd);
        Point p4 = line.getIntersection(da);
        if (this.isOnTheEdge(p1) || this.isVertex(p1)) {
            list.add(p1);
        }

        if (this.isOnTheEdge(p2) || this.isVertex(p2)) {
            if (!p2.equal(p1))
                list.add(p2);
        }

        if (this.isOnTheEdge(p3) || this.isVertex(p3)) {
            if (!p3.equal(p2) && !p3.equal(p1))
                list.add(p3);
        }
        
        if (this.isOnTheEdge(p4) || this.isVertex(p4)) {
            if ( !p4.equal(p3) && !p4.equal(p2) && !p4.equal(p1))
                list.add(p4);
        }

        return list;

    }
    public double[] calArea(Point point1, Point point2) {
        int p1, p2, p3, p4;
        double[] area = new double[2];
        Line l = new Line(point1, point2);
        p1 = l.getSideOfLine(a);
        p2 = l.getSideOfLine(b);
        p3 = l.getSideOfLine(c);
        p4 = l.getSideOfLine(d);

        if ((p1 == p2 && p2 == p3) || (p3 == 0 && (p1 == p2)) || (p1 == 0 && (p3 == p2)) || (p1 == p3))
            area[0] = new Triangle(d, point1, point2).getArea();
        else if ((p1 == p2 && p2 == p4) || (p2 == 0 && (p1 == p4)) || (p4 == 0 && (p1 == p2)) || (p2 == p4))
            area[0] = new Triangle(c, point1, point2).getArea();
        else if ((p1 == p3 && p4 == p3) || (p3 == 0 && (p1 == p4)) || (p1 == 0 && (p3 == p4)) || (p1 == p3))
            area[0] = new Triangle(b, point1, point2).getArea();
        else if ((p4 == p2 && p2 == p3) || (p2 == 0 && (p3 == p4)) || (p4 == 0 && (p3 == p2)) || (p2 == p4))
            area[0] = new Triangle(a, point1, point2).getArea();
        else if (p1 == p2 && p3 == p4) {
            if (bc.isBetween(point1))
                area[0] = new Quadrilateral(a, b, point1, point2).getArea();
            if (bc.isBetween(point2))
                area[0] = new Quadrilateral(a, b, point2, point1).getArea();
        } else if (p1 == p4 && p2 == p3) {
            if (ab.isBetween(point1))
                area[0] = new Quadrilateral(a, d, point2, point1).getArea();
            if (ab.isBetween(point2))
                area[0] = new Quadrilateral(a, d, point1, point2).getArea();
        }

        area[1] = this.getArea() - area[0];
        return area;
    }
}
////////
class ParseInput {
    
    public static void parseInput(String s, InputData d) {
        d.setChoice(getChoice(s.substring(0,1)));
        String[] str;
        str = s.substring(2).split("\\s+");
        for(String a : str) {
            parsePoints(a, d);
        }
        
    }

    public static int getChoice(String s) {
        return Integer.parseInt(s);
    }

    public static void parsePoints(String s, InputData d) {
        Point x = readPoint(s);
        d.addPoint(x);
    }

    public static Point readPoint(String s) {
        double x = 0,y = 0;
        int i = 0;
        while( s.charAt(i) != ',') {
            i++;
        }
        x = Double.parseDouble(s.substring(0, i));
        y = Double.parseDouble(s.substring(i+1));
        return new Point(x,y);
    }
}
////////
class LineInputError {

    public static void pointsCoincideError(Point p1, Point p2) {
        if (p1.equal(p2)) {
            System.out.println("points coincide");
            System.exit(0);
        }
    }
    
    public static void pointsCoincideError(Point p1, Point p2, Point p3, Point p4) {
        if (p1.equal(p2) || p1.equal(p3)|| p1.equal(p4)|| p2.equal(p3)|| p2.equal(p4)|| p3.equal(p4)) {
            System.out.println("points coincide");
            System.exit(0);
        }
    }
}
////////
class InputData {
    private int choice;
    private ArrayList<Point> points = new ArrayList<Point>();

    public int getChoice() {
        return choice;
    }

    public void setChoice(int choice) {
        this.choice = choice;
    }

    public ArrayList<Point> getPoints() {
        return points;
    }

    public void addPoint(Point p) {
        points.add(p);
    }
}
////////
class BasicType {
    public static void isBasicType(String s) {
        String regex = "[12345]\\:[\\+|-]?([0]|([1-9]((\\d)?)+))(\\.\\d+)?\\,([+\\-]?([0]|([1-9]((\\d)?)+)))(\\.\\d+)?(\\s([+\\-+]?([0]|([1-9]((\\d)?)+)))(\\.\\d+)?\\,([+\\-]?([0]|([1-9]((\\d)?)+)))(\\.\\d+)?){0,}";
        if(!s.matches(regex)) {
            System.out.println("Wrong Format");
            System.exit(0);
        }
    }
    public static String transfer(double c) {
        String str_d = String.valueOf(c);
              str_d = str_d.substring(str_d.indexOf(".") + 1);
                int len = str_d.length();
                len = len > 3 ? 3 : len;
                 String area1 = String.format("%."+len+"f", c);
                 return area1;
    }
}
////////
class PointInputError {
    public static void wrongNumberOfPoints(ArrayList<Point> ps, int num) {
        if (((num == 1 || num == 2 || num == 3) && ps.size() != 4) ||
                (num == 4 && ps.size() != 6) || 
                (num == 5 && ps.size() != 5)){
            System.out.println("wrong number of points");
            System.exit(0);
        }
    }
}

　　　　这个代码写的比之前的更加科学一点，不过老师好像说这样写其实也不是很好，不过确实比之前我那种写法要方便不少，最后这题只扣了5分，已经有了很大的进步！

　　　　这是类图：

　　　　这么写的好处很多，比如在判断三角形是否存在时，只需判断其中一点是否在另外两点上，如果不在就可以判断，而四边形也可以判断点是否在三角形三边或者顶点上，不在就是四边形，在内部就是凹

　　凹四边形，也就是说，如果最初就这么写的话，到最后这些代码都可以扒过来直接用的。甚至判断基本格式的时候正则表达式都不需要改变。

　　　　通过这次练习，我学到了了一些真正关于对象的的思考。不过有一些踩过的坑还是要说一说的。

　　　　其实还是老错误，就是对PTA题目的一些边界值判断，比如题目说的，按A，B，C，D顺序排列的点，并不是表示测试点没有乱序的点，而是需要我们自己去判断这些点顺序的正确性。有些方法写成静

　　静态static看似很简单，但是有时候是需要继承扩展的，写成static就会出问题。虽然静态方法可以继承，但是不能重写（也就是override），这样就做不到多态。不过这题其实并不需要考虑以后继承的问题　　　　

　　了，所以为了方便我还写成了静态的。

　　　　然后就是一些方法的实现的时候出了一系列问题，比如判断点是否在线段内的时候是否需要先判断点是否在直线上，在计算两直线交点的时候使用线代克拉默法则是否会更方便等。

　　3、ATM机系统：

　　　　这题的话还是题目没有看清楚就写完了，我甚至花了挺长时间来设计的，最后发现小丑竟是我自己。。。

　　　　PTA05-5:

　　　　这次作业依然没有获得满分，代码如下：

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Scanner;


public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Atm atm = new Atm();
        atm.work();
    }

}
class Atm {

    private DataAnalyze analyze = new DataAnalyze();
    private Execute execute = new Execute();
    private Display display = new Display();
    private LinkedList<User> dealtList = new LinkedList<User>();
    private LinkedList<User> originList = new LinkedList<User>();
    
    public void work() {
        originList = this.banckInitial(); 
        execute.setList(originList);
        analyze.setOriginList(originList);
        dealtList = analyze.cutList(initialization());
        for(User user : dealtList) {
            User u = analyze.find(user);
            if(analyze.getWrongFormat() == 0) {
                execute.execute(analyze.getOpreat(), u, analyze.getMoney());
                originList = execute.getList();
                display.show(analyze.getOpreat(), originList.get(execute.getIndex()),analyze.getMoney());
            } else {
                display.worngFormat(analyze.getWrongFormat());
            }
        }
        
    }
    
    public ArrayList<String> initialization() {
        Scanner input = new Scanner(System.in);
        ArrayList<String> str = new ArrayList<String>();
        String a = input.nextLine();
        while(!a.equals("#")) {
            str.add(a);
            a = input.nextLine();
        }
        input.close();
        return str;
    }
    
    public LinkedList<User> banckInitial() {
        LinkedList<User> list = new LinkedList<User>();
        User user1 = new User("杨过", "6217000010041315709", "10000.00", "", "88888888");
        User user2 = new User("杨过", "6217000010041315715", "10000.00", "", "88888888");
        User user3 = new User("杨过", "6217000010041315718", "10000.00", "", "88888888");
        User user4 = new User("郭靖", "6217000010051320007", "10000.00", "", "88888888");
        User user5 = new User("张无忌", "6222081502001312389", "10000.00", "", "88888888");
        User user6 = new User("张无忌", "6222081502001312390", "10000.00", "", "88888888");
        User user7 = new User("张无忌", "6222081502001312399", "10000.00", "", "88888888");
        User user8 = new User("张无忌", "6222081502001312400", "10000.00", "", "88888888");
        User user9 = new User("韦小宝", "6222081502051320785", "10000.00", "", "88888888");
        User user10 = new User("韦小宝", "6222081502051320786", "10000.00", "", "88888888");
        list.add(user1);
        list.add(user2);
        list.add(user3);
        list.add(user4);
        list.add(user5);
        list.add(user6);
        list.add(user7);
        list.add(user8);
        list.add(user9);
        list.add(user10);
        return list;
    }
}

class DataAnalyze {

    private LinkedList<User> originList = new LinkedList<User>();
    private int opreat,wrongFormat = 0;
    private double money = 0;
    private String num;
    
    public int getOpreat() {
        return opreat;
    }

    public int getWrongFormat() {
        return wrongFormat;
    }

    public void setOriginList(LinkedList<User> originList) {
        this.originList = originList;
    }

    public double getMoney() {
        return money;
    }

    public User find(User user) {
        if(user.getPassword() != null)
            return compare(user);
        else return query(user);
    }
    
    public User query(User user) {
        for(User a : this.originList) {
            if(a.getCardId().equals(user.getCardId())) {
                this.opreat = 0;
                this.wrongFormat = 0;
                return a;
            }else {
                this.wrongFormat = 1;
            }
        }
        return null;
    }
    
    public User compare(User user) {
        for(User a : this.originList) {
            if(a.getCardId().equals(user.getCardId())) {
                if(this.bankCardIDValidity(user.getAtmNumber())) {
                    if(user.getPassword().equals(a.getPassword())) {
                        if(this.bankCardIDValidity(user.getCardId(), user.getAtmNumber())) {
                            if(Double.parseDouble(user.getBalance()) <= Double.parseDouble(a.getBalance())) {
                                this.money = Double.parseDouble(user.getBalance());
                                this.wrongFormat = 0;
                                if(money <= 0)
                                    this.opreat = -1;
                                else if(money >= 0)
                                    this.opreat = 1;
                                a.setAtmNumber(this.num);
                                return a;
                            }else {
                                this.wrongFormat = 4;
                                return null;
                            }
                        }else {
                            this.wrongFormat = 5;
                            return null;
                        }
                    }else {
                        this.wrongFormat = 3;
                        return null;
                    }
                }else {
                    this.wrongFormat = 2;
                    return null;
                }
            }else {
                this.wrongFormat = 1;
            }
        }
        return null;
    }
    
    public boolean bankCardIDValidity(String cardID, String atm) {
        if(cardID.substring(0,10).equals("6217000010")) {
            if(atm.equals("01") || atm.equals("02") || atm.equals("03") ||atm.equals("04"))
                return true;
            else return false;
        }else if(cardID.substring(0,10).equals("6222081502")){
            if(atm.equals("05") || atm.equals("06"))
                return true;
            else return false;
        }else return false;
    }
    
    public boolean bankCardIDValidity(String atm) {
        if(atm.equals("01") || atm.equals("02") || atm.equals("03") || atm.equals("04") 
                || atm.equals("05") || atm.equals("06"))
            return true;
        else return false;
    }
    
    public LinkedList<User> cutList(ArrayList<String> originalData) {
        String[] str;
        LinkedList<User> list = new LinkedList<User>();
        User user;
        for(String data : originalData ) {
            str = data.split("\\s+");
            user = new User();
            if(str.length > 1) {
                user.setAtmNumber(str[2]);
                this.num = str[2];
                user.setBalance(str[3]);
                user.setCardId(str[0]);
                user.setPassword(str[1]);
            }else {
                user.setCardId(str[0]);
            }
            list.add(user);
        }
        return list;
    }
}


class Display {

    
    public void worngFormat(int wrongFormat) {
        if(wrongFormat == 1) {
            System.out.println("Sorry,this card does not exist.");
        }
        if(wrongFormat == 2) {
            System.out.println("Sorry,the ATM's id is wrong.");    
        }
        if(wrongFormat == 3) {
            System.out.println("Sorry,your password is wrong.");    
        }
        if(wrongFormat == 4) {
            System.out.println("Sorry,your account balance is insufficient.");
        }
        if(wrongFormat == 5) {
            System.out.println("Sorry,cross-bank withdrawal is not supported.");
        }
    }
    
    public void show(int oparate,User user,double money) {
        if(oparate == 1) {
            System.out.printf("%s在%s的%s号ATM机上取款¥%.2f\n",user.getName(),user.getBank(),user.getAtmNumber(),Math.abs(money));
            System.out.printf("当前余额为¥%.2f\n",Double.parseDouble(user.getBalance()));
        }
        if(oparate == -1) {
            System.out.printf("%s在%s的%s号ATM机上存款¥%.2f\n",user.getName(),user.getBank(),user.getAtmNumber(),Math.abs(money));
            System.out.printf("当前余额为¥%.2f\n",Double.parseDouble(user.getBalance()));
        }
        if(oparate == 0)
            System.out.printf("¥%.2f\n",Double.parseDouble(user.getBalance()));
    }
    
}

class Execute {

    private LinkedList<User> list = new LinkedList<User>();
    private int index;
    
    public int getIndex() {
        return index;
    }

    public LinkedList<User> getList() {
        return list;
    }
    
    public void setList(LinkedList<User> list) {
        this.list = list;
    }

    public void getIndex(User user) {
        index = list.indexOf(user);
    }
    
    public void execute(int oparate,User user,double money) {
        getIndex(user);
        whichBank(user.getCardId());
        doing(oparate,user,money);
    }
    
    public void doing(int oparate,User user,double money) {
        if(oparate == 0) {
        }else {
            double balance = Double.parseDouble(user.getBalance());
            balance -= money;
            list.get(index).setBalance(String.valueOf(balance));
        }
    }
    
    public void whichBank(String Id) {
        if(Id.substring(0,10).equals("6217000010")) {
            list.get(index).setBank("中国建设银行");
        }
        if(Id.substring(0,10).equals("6222081502")) {
            list.get(index).setBank("中国工商银行");
        }
    }
}
class User {
    /*
     * 用户信息类
     */

    private String name = null;
    private String cardId = null;
    private String balance = null;
    private String atmNumber = null;
    private String password = null;
    private String bank = null;
    
    public String getBank() {
        return bank;
    }

    public void setBank(String bank) {
        this.bank = bank;
    }

    public User(String name, String cardId, String balance, String atmNumber, String password) {
        super();
        this.name = name;
        this.cardId = cardId;
        this.balance = balance;
        this.atmNumber = atmNumber;
        this.password = password;
    }

    public User() {
        super();
        // TODO Auto-generated constructor stub
    }
    
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getCardId() {
        return cardId;
    }

    public void setCardId(String cardId) {
        this.cardId = cardId;
    }

    public String getBalance() {
        return balance;
    }

    public void setBalance(String balance) {
        this.balance = balance;
    }

    public String getAtmNumber() {
        return atmNumber;
    }

    public void setAtmNumber(String atmNumber) {
        this.atmNumber = atmNumber;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
    
    
}

　　　　类图：

 

 

 

　　　　这次作业出现的问题主要是以下几个方面：

　　　　1、没有认真审题，导致写道最后发现账户关系不对。

　　　　2、设计思想太低级，没有搞清楚银行，用户，账户，银行卡，ATM机等之间的关系。

　　　　个人认为其实这题设计思想应该是银行下有用户和ATM机，用户下有银行账户，账户下有银行卡和余额，银行卡有账号密码，Atm负责处理输入输出和数据处理。

　　　　

　　　　4、链表：

　　　　链表其实没太大问题，因为c语言基础不错，但是有一点不太懂，就是get(int index);这个方法的index到底是索引值还是第几个元素。或者说索引值是从0开始还是从1开始。老师上课写get和remove方法

　　的时候都是写第几个，也就是换到索引值的话是下标为 index-1 的元素进行操作。再写双链表的时候，其实也没太大问题，增加一个“指针”，指向前一个元素罢了。在一定程度上方便的增加删除的方便性。

　　DoublelinkedList:

public interface DoubleLinkedListImpl<E> {

    /**
     * 
     * 判断链表是否为空
     * 
     * @return
     * 
     */

    public boolean isEmpty();

    /**
     * 
     * 获取当前链表节点数量
     * 
     * @return 节点数
     * 
     */

    public int getSize();

    /**
     * 
     * 获取链表中第index个位置的节点的data值
     * 
     * @param index：节点在链表中的位置
     * 
     * @return：返回该节点的data值
     * 
     */

    public E getData(int index);

    /**
     * 
     * 删除链表最后一个节点
     * 
     */

    public void remove();

    /**
     * 
     * 删除链表中第index位置的节点
     * 
     * @param index：节点在链表中的位置
     * 
     */

    public void remove(int index);

    /**
     * 
     * 在链表的第index个位置之前插入一个节点，值为theElement，index∈[1,size]
     * 
     * @param index:插入节点在链表中的位置
     * 
     * @param theElement：新插入节点的data值
     * 
     */

    public void add(int index, E theElement);

    /**
     * 
     * 在链表尾插入节点，插入节点data值为element
     * 
     * @param element
     * 
     */

    public void add(E element);

    /**
     * 
     * 输出链表
     * 
     */

    public void printList();

    /**
     * 
     * 获取第一个节点的data值
     * 
     * @return
     * 
     */

    public E getFirst();

    /**
     * 
     * 获取链表最后一个节点的data值
     * 
     * @return
     * 
     */

    public E getLast();

}

public class Node<E> {
    private E data;// 数据域，类型为泛型E

    private Node<E> next;// 后继引用（指针）

    private Node<E> previous;// 前驱引用（指针）

    public Node(E data, Node<E> next, Node<E> previous) {
        super();
        this.data = data;
        this.next = next;
        this.previous = previous;
    }

    public Node() {
        // TODO Auto-generated constructor stub
    }

    public E getData() {
        return data;
    }

    public void setData(E data) {
        this.data = data;
    }

    public Node<E> getNext() {
        return next;
    }

    public void setNext(Node<E> next) {
        this.next = next;
    }

    public Node<E> getPrevious() {
        return previous;
    }

    public void setPrevious(Node<E> previous) {
        this.previous = previous;
    }
}

public class DoubleLinkedList<E> implements 
DoubleLinkedListImpl<E> {
    private Node<E> head;// 头结点，非第一个节点

    private Node<E> curr;// 当前节点

    private Node<E> tail;// 最后一个节点

    private int size;// 当前链表节点数

    public DoubleLinkedList() {
        super();
        this.head = new Node<E>();
        head.setNext(null);
        curr = tail = null;
        size = 0;
    }

    @Override
    public boolean isEmpty() {
        return this.size == 0;
    }

    @Override
    public int getSize() {
        return this.size;
    }

    @Override
    public E getData(int index) {
        curr = head;
        int num = 0;
        if (index < 0 || index >= size) {
            System.out.print("error!");
            return null;
        } else {
            while (true) {
                if (index-1 == num) {
                    return curr.getData();
                }
                curr = curr.getNext();
                num++;
            }
        }
    }

    @Override
    public void remove() {
        if (size <= 0)
            System.out.print("error!");
        else if (size == 1) {
            head = tail = null;
            this.size--;
        } else {
            tail.getPrevious().setNext(null);
            tail = tail.getPrevious();
            this.size--;
        }
    }

    @Override
    public void remove(int index) {
        if (index <= 0)
            System.out.print("error!");
        else {
            if (size == 1) {
                head = tail = null;
            } else if (index == 1) {
                head.getNext().setPrevious(null);
                head = head.getNext();
            } else if (index == size) {
                tail.getPrevious().setNext(null);
                tail = tail.getPrevious();
            } else {
                curr = head;
                for (int i = 1; i < index; i++) {
                    curr = curr.getNext();
                }
                curr.getPrevious().setNext(curr.getNext());
                curr.getNext().setPrevious(curr.getPrevious());
            }
            this.size--;
        }
    }

    @Override
    public void add(int index, E theElement) {
        curr = new Node<E>();
        curr.setData(theElement);
        curr.setNext(null);
        curr.setPrevious(null);

        if (index < 0 || index >= this.size) {
            System.out.print("error!");
        } else {
            if (size == 0) {
                head = curr;
                tail = curr;
            } else if (index == 0) {
                head.setPrevious(curr);
                curr.setNext(head);
                head = curr;
            } else if (index == size - 1) {
                tail.getPrevious().setNext(curr);
                curr.setPrevious(tail);
                tail = curr;
            } else {
                Node<E> p = head;
                for (int i = 0; i < index; i++)
                    p = p.getNext();
                p.getPrevious().setNext(curr);
                curr.setPrevious(p.getPrevious());
                p.setPrevious(curr);
                curr.setNext(p);
            }
            this.size++;
        }

    }

    @Override
    public void add(E element) {
        curr = new Node<E>();
        curr.setData(element);
        curr.setNext(null);

        if (size == 0) {
            head = tail = curr;
            curr.setPrevious(null);
        } else {
            tail.setNext(curr);
            curr.setPrevious(tail);
        }
        this.size += 1;
        tail = curr;
    }

    @Override
    public void printList() {
        curr = head;
        if (size > 0) {
            for (int i = 0; i < size; i++) {
                System.out.print(curr.getData() + " ");
                curr = curr.getNext();
            }
            System.out.println();
        }
    }

    @Override
    public E getFirst() {
        return head.getData();
    }

    @Override
    public E getLast() {
        return tail.getData();
    }

}

　　　　这是三个类，主要就是注意一下边界的问题，还有一些特殊情况比如头为空的判断，还有一些“指针”指向逻辑，还有确保node的封装性等等。而且我发现Java的linkedlist是双向指针，索引是从0开始的。

　　链表的难度不是很高，但是对于我们了解一些结构运行上有很大帮助！

 

　　　　5：农夫过河：

　　　　这题从最开始的三类，不过比较老师已经写好了大部分，所以其实就一些类的设计上是比较简单的，只需要填充一些方法就行了。这部分代码也就不一一展示了，在迭代了一轮之后，我添加了几个父            类，不过依然感觉有些欠缺。先给代码吧

package 农夫过河;

public class Main {
        public static void main(String[] args) {
            // TODO Auto-generated method stub
            Game game = new Game();
            game.play();
    }
}

package 农夫过河;

public class GameGui {
    
    public void modleChoose() {
        System.out.println("==================Choose the game mode:==================");
        System.out.println("==========1:Five roles and can take two characters across the river==========");
        System.out.println("==========2:Three roles and only take one character across the river==========");
    }
    
    public void menu1() {
        System.out.println("==================Please choose operation============");
        System.out.println("\t==========1:Cross the river alone===========");
        System.out.println("\t==========2:Cross the river with wolf=========");
        System.out.println("\t==========3:Cross the river with sheep============");
        System.out.println("\t==========4:Cross the river with rabbit==========");
        System.out.println("\t==========5:Cross the river with cabbage=========");
        System.out.println("\t==========6:Cross the river with carrot============");
        System.out.println("\t==========7:Cross the river with wolf and sheep=========");
        System.out.println("\t==========8:Cross the river with wolf and rabbit============");
        System.out.println("\t==========9:Cross the river with wolf and cabbage============");
        System.out.println("\t==========10:Cross the river with wolf and carrot============");
        System.out.println("\t==========11:Cross the river with sheep and rabbit============");
        System.out.println("\t==========12:Cross the river with sheep and cabbage============");
        System.out.println("\t==========13:Cross the river with sheep and carrot============");
        System.out.println("\t==========14:Cross the river with rabbit and cabbage============");
        System.out.println("\t==========15:Cross the river with rabbit and carrot============");
        System.out.println("\t==========16:Cross the river with cabbage and carrot==========");
        System.out.println("\t==========0:Quit===============");   
        System.out.println("===================================================");
        System.out.println("Input the number(0~16):");
    }
    
    public void menu2() {
        /* 显示菜单 */
        System.out.println("==================Please choose operation============");
        System.out.println("\t==========1:Cross the river alone===========");
        System.out.println("\t==========2:Cross the river with wolf=========");
        System.out.println("\t==========3:Cross the river with sheep============");
        System.out.println("\t==========4:Cross the river with cabbage==========");
        System.out.println("\t==========0:Quit===============");   
        System.out.println("===================================================");
        System.out.println("Input the number(0~4):");
    }    

    public void showStatus(Passenger farmer, Passenger wolf, Passenger sheep, Passenger cabbage) {
    /* 输出农夫、各种动物、物品的状态（生存、位置） */
        farmer.showStatus();
        wolf.showStatus();
        sheep.showStatus();
        cabbage.showStatus();
    }
    
    public void showStatus(Passenger farmer, Passenger wolf, Passenger sheep, Passenger cabbage,
            Passenger rabbit, Passenger carrot) {
        /* 输出农夫、各种动物、物品的状态（生存、位置） */
            farmer.showStatus();
            wolf.showStatus();
            sheep.showStatus();
            rabbit.showStatus();
            cabbage.showStatus();
            carrot.showStatus();
        }

}

package 农夫过河;

public abstract class Passenger {
    private boolean crossRiver = false;
    
    public boolean isCrossRiver() {
        return crossRiver;
    }

    public void setCrossRiver(boolean crossRiver) {
        this.crossRiver = crossRiver;
    }
    
    public void showStatus() {
    }

    public Passenger(boolean crossRiver) {
        super();
        this.crossRiver = crossRiver;
    }

    public Passenger() {
        // TODO Auto-generated constructor stub
    }
}

　　

package 农夫过河;

public class Farmer extends Passenger{

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

    @Override
    public void showStatus() {
        System.out.println("Farmer has Cross  :" + isCrossRiver());
    }    

}

package 农夫过河;

public abstract class Animal extends Passenger {

    private String name;

    public Animal(String name) {
        super();
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

}

package 农夫过河;

public class Wolf extends Animal{
        
        public Wolf(String name) {
            super(name);
            System.out.println("啊呜~~~我 "+ name +" 又回来了");
        }
        
        @Override
        public void showStatus() {
            System.out.println("Wolf has Cross  :" + isCrossRiver());
        }

        public void eat(Farmer farmer, VegetarianAnimal animal) {
            if(farmer.isCrossRiver() != this.isCrossRiver())
                if(this.isCrossRiver() == animal.isCrossRiver())
                    animal.beEaten();
        }


}

package 农夫过河;

public class VegetarianAnimal extends Animal {

    private boolean isAlive = true;

    public VegetarianAnimal(String name) {
        super(name);
        // TODO Auto-generated constructor stub
    }

    public boolean isAlive() {
        return isAlive;
    }

    public void beEaten() {
        this.isAlive = false;
    }
    
    public void eat(Farmer farmer, Botany botany) {
        if(farmer.isCrossRiver() != this.isCrossRiver())
            if(this.isCrossRiver() == botany.isCrossRiver())
                botany.beEaten();
    }

}

package 农夫过河;

public class Sheep extends VegetarianAnimal{
    
    public Sheep(String name) {
        super(name);
        System.out.println("咩咩，我是可爱的小羊 "+ name );
    }
    
    @Override
    public void showStatus() {
        System.out.println("Sheep "+ this.getName() +" is alive :" + this.isAlive());
        System.out.println("Sheep has Cross  :" + isCrossRiver());
    }
}

package 农夫过河;

public class Rabbit extends VegetarianAnimal {

    public Rabbit(String name) {
        super(name);
        // TODO Auto-generated constructor stub
        System.out.println("我是" + name);
    }

    @Override
    public void showStatus() {
        System.out.println("Rabbit "+ this.getName() +" is alive :" + this.isAlive());
        System.out.println("Rabbit has Cross  :" + isCrossRiver());
    }
}

package 农夫过河;

public abstract class Botany extends Passenger {
    private boolean isAlive = true;

    public boolean isAlive() {
        return isAlive;
    }

    public void beEaten() {
        this.isAlive = false;
    }
}

package 农夫过河;

public class Cabbage extends Botany {
    
    @Override
    public void showStatus() {
        System.out.println("Cabbage has Cross  :" + isCrossRiver());
    }

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

}

package 农夫过河;

public class Carrot extends Botany {

    @Override
    public void showStatus() {
        System.out.println("Carrot has Cross  :" + isCrossRiver());
    }

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

package 农夫过河;

public class Boat {

    public boolean isRightLocation(int choose, Passenger farmer, Passenger wolf, Passenger sheep, Passenger cabbage) {
        if(choose == 2) {
            if(wolf.isCrossRiver() == farmer.isCrossRiver())
                return true;
            else return false;
        }
        if(choose == 3) {
            if(sheep.isCrossRiver() == farmer.isCrossRiver())
                return true;
            else return false;
        }
        if(choose == 4){
            if(cabbage.isCrossRiver() == farmer.isCrossRiver())
                return true;
            else return false;
        }
        else return true;
    }
    
    public boolean isRightLocation(int choose, Passenger farmer, Passenger wolf, Passenger sheep, Passenger cabbage,
            Passenger rabbit, Passenger carrot) {
        if(choose == 2) {
            if(wolf.isCrossRiver() == farmer.isCrossRiver())
                return true;
            else return false;
        }
        if(choose == 3) {
            if(sheep.isCrossRiver() == farmer.isCrossRiver())
                return true;
            else return false;
        }
        if(choose == 4){
            if(rabbit.isCrossRiver() == farmer.isCrossRiver())
                return true;
            else return false;
        }
        if(choose == 5) {
            if(cabbage.isCrossRiver() == farmer.isCrossRiver())
                return true;
            else return false;
        }
        if(choose == 6) {
            if(carrot.isCrossRiver() == farmer.isCrossRiver())
                return true;
            else return false;
        }
        if(choose == 7){
            if(wolf.isCrossRiver() == farmer.isCrossRiver() && wolf.isCrossRiver() == sheep.isCrossRiver())
                return true;
            else return false;
        }
        if(choose == 8) {
            if(wolf.isCrossRiver() == farmer.isCrossRiver()&& wolf.isCrossRiver() == rabbit.isCrossRiver())
                return true;
            else return false;
        }
        if(choose == 9) {
            if(wolf.isCrossRiver() == farmer.isCrossRiver()&& wolf.isCrossRiver() == cabbage.isCrossRiver())
                return true;
            else return false;
        }
        if(choose == 10){
            if(wolf.isCrossRiver() == farmer.isCrossRiver()&& wolf.isCrossRiver() == carrot.isCrossRiver())
                return true;
            else return false;
        }
        if(choose == 11) {
            if(sheep.isCrossRiver() == farmer.isCrossRiver()&& sheep.isCrossRiver() == rabbit.isCrossRiver())
                return true;
            else return false;
        }
        if(choose == 12) {
            if(sheep.isCrossRiver() == farmer.isCrossRiver()&& sheep.isCrossRiver() == cabbage.isCrossRiver())
                return true;
            else return false;
        }
        if(choose == 13){
            if(sheep.isCrossRiver() == farmer.isCrossRiver()&& sheep.isCrossRiver() == carrot.isCrossRiver())
                return true;
            else return false;
        }
        if(choose == 14) {
            if(rabbit.isCrossRiver() == farmer.isCrossRiver()&& rabbit.isCrossRiver() == cabbage.isCrossRiver())
                return true;
            else return false;
        }
        if(choose == 15) {
            if(rabbit.isCrossRiver() == farmer.isCrossRiver()&& rabbit.isCrossRiver() == carrot.isCrossRiver())
                return true;
            else return false;
        }
        if(choose == 16){
            if(cabbage.isCrossRiver() == farmer.isCrossRiver() && carrot.isCrossRiver() == cabbage.isCrossRiver())
                return true;
            else return false;
        }
        else return true;
    }
}

　　　　类图：

 

 

 　　　　在做这个实验的时候我妄图使用一个父类，但发现一个父类做不到这些事，因为就比如eat方法，蔬菜是不会吃的，还有isAlive这个属性wolf也没有，于是我就写了这么多的父类来实现。此次实验，如　　　　　　　　　　　　　　　　

　　果写好父类的话，可以大大减少写子类的时间。大多时候只是增加了菜单界面的修改。这次试验让我更加了解到代码复用性和可扩展性的重要。不过此次实验仍有不完美的地方，比如eat这个方法任然没把

　　他写在父类中做到真正的多态，然后game函数太复杂。还有就是多态其实也做得不太好，但是我确实是没有其他办法了。

             

　　　　6、期中考试：

　　　　期中考试没啥说的，类图都给了，总不能写不出来吧。依我看，这个不就是MOOC里面老师讲的嘛，什么Item类，然后DataBase里加一个Item，意思都一样，主要考察的是多态

　　　　期中：

import java.util.ArrayList;
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        GeometryObject o = new GeometryObject();
         
        Scanner input = new Scanner(System.in);
        int choice;

        choice = input.nextInt();
        while (choice != 0) {
            switch (choice) {
            case 1:// insert Point object into list
                o.add(new Point(input.nextDouble(),input.nextDouble()));
                break;
            case 2:// insert Line object into list
                o.add(new Line(new Point(input.nextDouble(),input.nextDouble()),new Point(input.nextDouble(),input.nextDouble()),input.next()));
                break;
            case 3:// insert Plane object into list
                o.add(new Plane(input.next()));
                break;
            case 4:// delete index - 1 object from list
                int index = input.nextInt();
                if(index <= o.getList().size() && index > 0)
                    o.remove(index-1);
            }
            choice = input.nextInt();
        }
        
        for(Element e : o.getList()) {
            e.display();
        }
        input.close();
    }

}
abstract class Element {
    public void display() {
        
    }
}
class Point extends Element{
    private double x,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;
    }
    
    @Override
    public void display() {
        if(x > 0 && x <= 200 && y > 0 && y <= 200)
            System.out.printf("(%.2f,%.2f)\n",x,y);
        else System.out.println("Wrong Format");
    }
}
class Line extends Element{
    private Point point1;
    private Point point2;
    private String color = null;

    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(){
        return Math.sqrt(Math.pow(point1.getX() - point2.getX(), 2) + 
                         Math.pow(point1.getY() - point2.getY(), 2));
    }
    
    @Override
    public void display() {
        if(point1.getX() > 0&& point1.getX() < 200 && point1.getY() > 0 && point1.getY() < 200 &&
          point2.getX() > 0&& point2.getX() < 200 && point2.getY() > 0 && point2.getY() < 200){
            System.out.println("The line's color is:" + color);
            System.out.println("The line's begin point's Coordinate is:");
            point1.display();
            System.out.println("The line's end point's Coordinate is:");
            point2.display();
            System.out.printf("The line's length is:%.2f\n" , getDistance());
        }else
            System.out.println("Wrong Format");
        
    }
}
class Plane extends Element {
    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;
    }
    
    @Override
    public void display() {
        System.out.println("The Plane's color is:" + color);
    }
}
class GeometryObject {
    private ArrayList<Element> list = new ArrayList<Element>();

    public ArrayList<Element> getList() {
        return list;
    }

    public void add(Element element) {
        list.add(element);
    }

    public void remove(int index) {
        list.remove(index);
    }

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

}

 

　　　　　　 　　　　这里特别的需要注意边界值，index并不是自动会屏蔽，而是需要人为判断，（虽然题目这样我每次都会忽略。。。）。

 

课堂内容：

　　Set: 集合，内部元素不可重复。还接触到了hashcode这种东西，哈希算法一般用于排序查找比较方便。不过hashset里面的和输入的元素是乱序的，不过有linkedhashset，这个顺序不打乱

　　Map：图，有HashMap，TreeMap，这里又接触到树这个数据结构。大的放右边，小的放左边，查大小非常方便，不过只是初步接触。以后学的时候肯定掉头发。

　　Stream：流，可用于一些数据的间接操作和终止操作，不是必要，但是也要了解。

 

以上就是这个阶段下来的Java学习的主要内容了，虽然疫情之下搞得我真的难受，PTA写的也真的秃头，但是以后靠这个吃饭的家伙，还是得好好学啊。。。

　　　　最后：蟹蟹阅读，留下你的小心心吧^-^!

参考文献：菜鸟教程 https://www.runoob.com/

　　　　　CSDN https://www.csdn.net/