第二次Blog作业

前言

　　这几次作业主要考察对于继承与多态、正则表达式、Lambda表达式、JavaFX和类设计，尤其是对于类设计的考察程度更加深入。

同时，这几次作业相比前几个星期的难度提升很大，需要投入更多的时间。

设计与分析

ATM机类结构设计

题目描述如下：

类图如下：

 

 

源码如下：

 

import java.util.ArrayList;
import java.util.Scanner;
import javax.xml.parsers.*;
import org.w3c.dom.*;
import java.io.*;
 
public class Main {

    public static void main(String[] args) {
          ATM atm;
          atm = (ATM)XMLUtil.getBean("ATM");
          atm.start();
  }

}

class Account {
private double money;
private String bankID;
private ArrayList<Card> cards = new ArrayList();

public Account() {
this.money = 10000.00;
}

public Account(String bankID) {
this.bankID = bankID;
this.money = 10000.00;
}

public double getMoney() {
return money;
}

public void setMoney(double money) {
this.money = money;
}

public String getAccountID() {
return bankID;
}

public void setAccountID(String accountID) {
this.bankID = accountID;
}

public ArrayList<Card> getCards() {
return cards;
}

public void setCards(ArrayList<Card> cards) {
this.cards = cards;
}

}

class ATM {
    private Control control = new Control01();
    
    public ATM() {
    }

    public void start() {
        control.getInput().input();
        while(control.getInput().getPoints()[0].equals("#") == false) {
            if(control.judge1(control.getInput())) {
                if(control.getInput().getPoints().length == 1) {
                    System.out.printf("¥%.2f",getBalance(control.getInput()));
                }else {
                    if(control.judge2(control.getInput())) {
                        if(control.judge3(control.getInput())) {
                            if(control.judge5(control.getInput())) {
                                double money = Double.parseDouble(control.getInput().getPoints()[3]);
                                if(money<0) {
                                    change(control.getInput(),money);
                                    System.out.printf(getUserName(control.getInput())+"在"+getBankName(control.getInput())+"的"+control.getInput().getPoints()[2]+"号ATM机上存款¥%.2f",-money);
                                    System.out.println("");
                                    System.out.printf("当前余额为¥%.2f",getBalance(control.getInput()));
                                }else {
                                    change(control.getInput(),money);
                                    if(control.judge4(getBalance(control.getInput()))) {
                                        System.out.printf(getUserName(control.getInput())+"在"+getBankName(control.getInput())+"的"+control.getInput().getPoints()[2]+"号ATM机上取存款¥%.2f",money);
                                        System.out.println("");
                                        System.out.printf("当前余额为¥%.2f",getBalance(control.getInput()));
                                    }else {
                                        Output.output(4);
                                        change(control.getInput(),-money);
                                    }
                                }
                            }else {
                                Output.output(5);
                            }
                        }else {
                            Output.output(3);
                        }
                    } else {
                        Output.output(2);
                    }
                }
            }else {
                Output.output(1);
            }
            control.getInput().input();
        }
    }
    
    public double getBalance(Input input) {
        int[] index = control.getIndex(input);
        double balance = control.getUnionPay().getBanks().get(index[0]).getUsers().get(index[1]).getAccounts().get(index[2]).getMoney();
        return balance;
    }
    
    public String getUserName(Input input) {
        int[] index = control.getIndex(input);
        String useName = control.getUnionPay().getBanks().get(index[0]).getUsers().get(index[1]).getUserName();
        return useName;
    }
    
    public String getBankName(Input input) {
        int[] index = control.getIndex(input);
        String bankName = control.getUnionPay().getBanks().get(index[0]).getBankName();
        return bankName;
    }
    
    public void change(Input input,double money) {
        int[] index = control.getIndex(input);
        control.getUnionPay().getBanks().get(index[0]).getUsers().get(index[1]).getAccounts().get(index[2]).setMoney(getBalance(input) - money);
    }
}

class ATM01 extends ATM{

    public ATM01() {
        super();
    }

}

class Bank {
    private String bankName;
    private ArrayList<User> users = new ArrayList();
    private ArrayList<String> IDsOfATM = new ArrayList();
    
    public Bank() {
    }

    public Bank(String bankName) {
        this.bankName = bankName;
    }
    
    public String getBankName() {
        return bankName;
    }

    public void setBankName(String bankName) {
        this.bankName = bankName;
    }

    public ArrayList<User> getUsers() {
        return users;
    }

    public void setUsers(ArrayList<User> users) {
        this.users = users;
    }

    public ArrayList<String> getIDsOfATM() {
        return IDsOfATM;
    }

    public void setIDsOfATM(ArrayList<String> iDsOfATM) {
        IDsOfATM = iDsOfATM;
    }
    
    public void addIDsOfATM(String[] ID) {
        for(int i = 0;i < ID.length;i++) {
            IDsOfATM.add(ID[i]);
        }
    }
}

class Bank01 extends Bank{

    public Bank01() {
        super();
    }
    
    public Bank01(String bankName) {
        super(bankName);
    }

}

class Card {
    private String classOfCard;
    private String cardID;
    private String password;
    
    public Card() {
    }
    
    public Card(String classOfCard,String cardID) {
        this.classOfCard = classOfCard;
        this.cardID = cardID;
        this.password = "88888888";
    }

    public String getCardID() {
        return cardID;
    }

    public void setCardID(String cardID) {
        this.cardID = cardID;
    }

    public String getClassOfCard() {
        return classOfCard;
    }

    public void setClassOfCard(String classOfCard) {
        this.classOfCard = classOfCard;
    }

    public String getPassword() {
        return password;
    }

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

class Control {
    private UnionPay unionPay = new UnionPay();
    private Input input = new Input();
    
    public Control() {
        intialize();
    }
    
    public UnionPay getUnionPay() {
        return unionPay;
    }

    public void setUnionPay(UnionPay unionPay) {
        this.unionPay = unionPay;
    }
    
    public Input getInput() {
        return input;
    }

    public void setInput(Input input) {
        this.input = input;
    }

    public void intialize() {
        unionPay.getBanks().add(new Bank01("中国建设银行"));
        unionPay.getBanks().add(new Bank01("中国工商银行"));
        //ATM序号
        String[] ATM1 = {"01","02","03","04"};
        unionPay.getBanks().get(0).addIDsOfATM(ATM1);
        String[] ATM2 = {"05","06"};
        unionPay.getBanks().get(1).addIDsOfATM(ATM2);
        //建设
        //杨过
        unionPay.getBanks().get(0).getUsers().add(new User01("杨过"));
        unionPay.getBanks().get(0).getUsers().get(0).getAccounts().add(new Account("3217000010041315709"));
        unionPay.getBanks().get(0).getUsers().get(0).getAccounts().get(0).getCards().add(new DebitCard("6217000010041315709"));
        unionPay.getBanks().get(0).getUsers().get(0).getAccounts().get(0).getCards().add(new DebitCard("6217000010041315715"));
        unionPay.getBanks().get(0).getUsers().get(0).getAccounts().add(new Account("3217000010041315709"));
        unionPay.getBanks().get(0).getUsers().get(0).getAccounts().get(1).getCards().add(new DebitCard("6217000010041315718"));
        //郭靖
        unionPay.getBanks().get(0).getUsers().add(new User01("郭靖"));
        unionPay.getBanks().get(0).getUsers().get(1).getAccounts().add(new Account("3217000010051320007"));
        unionPay.getBanks().get(0).getUsers().get(1).getAccounts().get(0).getCards().add(new DebitCard("6217000010051320007"));
        //工商
        //张无忌
        unionPay.getBanks().get(1).getUsers().add(new User01("张无忌"));
        unionPay.getBanks().get(1).getUsers().get(0).getAccounts().add(new Account("3222081502001312389"));
        unionPay.getBanks().get(1).getUsers().get(0).getAccounts().get(0).getCards().add(new DebitCard("6222081502001312389"));
        unionPay.getBanks().get(1).getUsers().get(0).getAccounts().add(new Account("3222081502001312390"));
        unionPay.getBanks().get(1).getUsers().get(0).getAccounts().get(1).getCards().add(new DebitCard("6222081502001312390"));
        unionPay.getBanks().get(1).getUsers().get(0).getAccounts().add(new Account("3222081502001312399"));
        unionPay.getBanks().get(1).getUsers().get(0).getAccounts().get(2).getCards().add(new DebitCard("6222081502001312399"));
        unionPay.getBanks().get(1).getUsers().get(0).getAccounts().get(2).getCards().add(new DebitCard("6222081502001312400"));
        //韦小宝
        unionPay.getBanks().get(1).getUsers().add(new User01("韦小宝"));
        unionPay.getBanks().get(1).getUsers().get(1).getAccounts().add(new Account("3222081502051320785"));
        unionPay.getBanks().get(1).getUsers().get(1).getAccounts().get(0).getCards().add(new DebitCard("6222081502051320785"));
        unionPay.getBanks().get(1).getUsers().get(1).getAccounts().add(new Account("3222081502051320786"));
        unionPay.getBanks().get(1).getUsers().get(1).getAccounts().get(1).getCards().add(new DebitCard("6222081502051320786"));
    }
    public int[] getIndex(Input input) {
        int[] index = new int[4];
        for(int i = 0;i < unionPay.getBanks().size(); i++) {
            for(int j = 0;j < unionPay.getBanks().get(i).getUsers().size(); j++) {
                for(int k = 0;k < unionPay.getBanks().get(i).getUsers().get(j).getAccounts().size(); k++) {
                    for(int l = 0;l < unionPay.getBanks().get(i).getUsers().get(j).getAccounts().get(k).getCards().size(); l++) {
                        String cardID = unionPay.getBanks().get(i).getUsers().get(j).getAccounts().get(k).getCards().get(l).getCardID();
                        if(input.getPoints()[0].equals(cardID)) {
                            index[0] = i;
                            index[1] = j;
                            index[2] = k;
                            index[3] = l;
                        }
                    }
                }
            }
        }
        return index;
    }
    
    public boolean judge1(Input input) {
        boolean result = false;
        for(int i = 0;i < unionPay.getBanks().size(); i++) {
            for(int j = 0;j < unionPay.getBanks().get(i).getUsers().size(); j++) {
                for(int k = 0;k < unionPay.getBanks().get(i).getUsers().get(j).getAccounts().size(); k++) {
                    for(int l = 0;l < unionPay.getBanks().get(i).getUsers().get(j).getAccounts().get(k).getCards().size(); l++) {
                        String cardID = unionPay.getBanks().get(i).getUsers().get(j).getAccounts().get(k).getCards().get(l).getCardID();
                        if(input.getPoints()[0].equals(cardID)) {
                            result = true;
                        }
                    }
                }
            }
        }
        return result;
    }
    
    public boolean judge2(Input input) {
        boolean result = false;
        
        if(unionPay.getBanks().get(0).getIDsOfATM().contains(input.getPoints()[2])||unionPay.getBanks().get(1).getIDsOfATM().contains(input.getPoints()[2])) {
            result = true;
        }
        return result;
    }
    
    public boolean judge3(Input input) {
        boolean result = false;
        int[] index = getIndex(input);
        String password = unionPay.getBanks().get(index[0]).getUsers().get(index[1]).getAccounts().get(index[2]).getCards().get(index[3]).getPassword();
        if(input.getPoints()[1].equals(password)) {
            result = true;
        }
        return result;
    }
    
    public boolean judge4(double balance) {
        boolean result = true;
        if(balance < 0) {
            result = false;
        }
        return result;
    }
    
    public boolean judge5(Input input) {
        boolean result = false;
        int[] index = getIndex(input);
        if(unionPay.getBanks().get(index[0]).getIDsOfATM().contains(input.getPoints()[2])) {
            result = true;
        }
        return result;
    }
}

class Control01 extends Control{

    public Control01() {
        super();
    }

}

class DebitCard extends Card{

    public DebitCard(String cardID) {
        super("借记卡",cardID);
    }

}

class Input {
    private String[] points;

    public Input() {
    }

    public String[] getPoints() {
        return points;
    }

    public void setPoints(String[] points) {
        this.points = points;
    }
    
    public void input() {
        Scanner in = new Scanner(System.in);
        String allPoints = in.nextLine();
        this.points = allPoints.split("\\s+");
    }
}

class Output {

    public Output() {
    }

    public static void output(int choice) {
        switch(choice) {
        case 1:
            System.out.println("Sorry,this card does not exist.");
            break;
        case 2:
            System.out.println("Sorry,the ATM's id is wrong.");
            break;
        case 3:
            System.out.println("Sorry,your password is wrong.");
            break;
        case 4:
            System.out.println("Sorry,your account balance is insufficient.");
            break;
        case 5:
            System.out.println("Sorry,cross-bank withdrawal is not supported.");
            break;
        }
    }
}

class UnionPay {
    private ArrayList<Bank> banks = new ArrayList();
    
    public UnionPay() {
    }

    public ArrayList<Bank> getBanks() {
        return banks;
    }

    public void setBanks(ArrayList<Bank> banks) {
        this.banks = banks;
    }
    
}

class User {
    private String userName;
    private ArrayList<Account> accounts = new ArrayList();
    
    public User() {
    }
    
    public User(String userName) {
        this.userName = userName;
    }
    
    public User(String userName,String bankID,String cardID) {
        this.userName = userName;
        
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public ArrayList<Account> getAccounts() {
        return accounts;
    }

    public void setAccounts(ArrayList<Account> accounts) {
        this.accounts = accounts;
    }
    
}

class User01 extends User{

    public User01() {
        // TODO Auto-generated constructor stub
    }
    
    public User01(String userName) {
        super(userName);
    }

}

class XMLUtil {
    //该方法用于从XML配置文件中提取具体类类名，并返回一个实例对象
    public static Object getBean(String args) {
        try {
            //创建文档对象
            DocumentBuilderFactory dFactory = DocumentBuilderFactory.newInstance();
            DocumentBuilder builder = dFactory.newDocumentBuilder();
            Document doc;                            
            doc = builder.parse(new File("src//test13//config.xml")); 
            NodeList nl=null;
            Node classNode=null;
            String cName=null;
            nl = doc.getElementsByTagName("className");
            
            //获取第一个包含类名的结点
            if(args.equals("ATM")) {
                classNode=nl.item(0).getFirstChild();
                
            }
            
            cName=classNode.getNodeValue();
            //通过类名生成实例对象并将其返回
            Class c=Class.forName(cName);
              Object obj=c.newInstance();
            return obj;        
        }   
        catch(Exception e) {
            e.printStackTrace();
            return null;
        }
    }
}

 

分析如下：此为我之后改进过的，在改进中我用到了继承和修改配置文件更改变量的方法以便于以后的迭代。在改进中我投入了很多时间，这也让我收获很多。

 

链表练习

题目说明如下：

类图如下：无

源码如下：

public class Main {

    public static void main(String[] args) {//下标从0开始
        Llist<String> list = new Llist<String>();
        //测试addisEmpty
        System.out.println("测试isEmpty:");
        if(list.isEmpty()) {
            System.out.println("...");
        }
        list.add("a");
        if(list.isEmpty()) {
            System.out.println("...");
        }
        //测试add
        System.out.println("测试add:");
        list.printList();
        list.add("b");
        list.add("c");
        list.printList();
        System.out.println(list.getData(1));
        //测试add(插入)
        System.out.println("测试add(插入):");
        list.printList();
        list.add(0,"d");
        System.out.println(list.getData(0));
        list.printList();
        list.add(3,"e");
        list.printList();
        //测试remove
        System.out.println("测试remove:");
        list.printList();
        list.remove(1);
        list.printList();
        //测试getFirst和getLast
        System.out.println("测试getFirst和getLast:");
        list.printList();
        System.out.println(list.getFirst());
        System.out.println(list.getLast());
        //测试getSize
        System.out.println("测试getSize:");
        list.printList();
        System.out.println(list.getSize());
        list.add("f");
        list.printList();
        System.out.println(list.getSize());
    }
}

class Node<E>{
    private E o;
    private Node<E> next;
    private Node<E> previous;
    
    public Node() {
    }
    
    public Node(E o,Node<E> previous,Node<E> next) {
        this.o = o;
        this.previous  =previous;
        this.next  =next;
    }
    
    public E getO() {
        return o;
    }
    public void setO(E o) {
        this.o = o;
    }
    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;
    }
     
}

interface LinearListInterface<E>{

    public boolean isEmpty();

    public int getSize();

    public E getData(int index);

    public void remove(int index);

    public void add(int index, E theElement);

    public void add(E  element);

    public void printList();    

    public E getFirst(); 

    public E getLast();
}

class Llist<E> implements LinearListInterface<E>{
    private Node<E> head = new Node();
    private Node<E> curr;
    private Node<E> tail;
    private int size = 0;
    
    public Llist() {    
    }
    
    public boolean isEmpty() {
        return size == 0;
    }

    public int getSize() {
        return size;
    }

    public E getData(int index) {
        if(index >= size) {
            System.out.println("Wrong Index");
            System.exit(0);
        }
        curr = head;
        for(int i = 0;i < index + 1; i++) {
            curr = curr.getNext();
        }
        return curr.getO();
    }

    public void remove(int index) {
        if(index >= size) {
            System.out.println("Wrong Index");
            System.exit(0);
        }
        curr = head;
        for(int i = 0;i < index ; i++) {
            curr = curr.getNext();
        }
        curr.setNext(curr.getNext().getNext());
        size--;
    }

    public void add(int index, E theElement) {
        if(index >= size) {
            System.out.println("Wrong Index");
            System.exit(0);
        }
        curr = head;
        for(int i = 0;i < index; i++) {
            curr = curr.getNext();
        }
        Node<E> newnode = new Node<E>(theElement,curr,curr.getNext());
        curr = head;
        for(int i = 0;i < index; i++) {
            curr = curr.getNext();
        }
        curr.setNext(newnode);
        size++;
    }

    public void add(E  element) {
        if(this.isEmpty()) {
            curr = new Node<E>(element,null,null);
            head.setNext(curr);
            tail = curr;
            size ++;
        }else {
            curr = tail;
            tail = new Node<E>(element,curr.getPrevious(),null);
            curr.setNext(tail);
            size ++;
        }
        
    }

    public void printList() {
        curr = head.getNext();
        while(curr != null) {
            System.out.print("[" + curr.getO() + "]");
            curr = curr.getNext();
        }
        System.out.println(" ");
    }
    
    public E getFirst(){
        return head.getNext().getO();
    }

    public E getLast() {
        return tail.getO();
    }
}

源码如下：本题主要考察对于链表的理解以及接口的灵活使用。而对于链表的理解尤为重要，否则根本无从下手。同时把头指针设为空更好一点（我此处没有），因为这样便于实现在index为0前插入。

点线形系列

题目说明如下：

类图如下：无

源码如下：

 

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);;
        Judge judge = new Judge();
        String allPoints = in.nextLine();
        String[] half = allPoints.split(":");
        int choice = Integer.parseInt(half[0]);
        String[] points = half[1].split("\\s+");
        Calculate calculate = new Calculate();
        if(judge.formatValidate(points)) {
            switch(choice) {
            case 1 :
                if(judge.numValidate(2,points)) {
                    calculate.choose1(points);
                } else {
                    System.out.println("wrong number of points");
                }
                    break;
            case 2 :
                if(judge.numValidate(3,points)) {
                    calculate.choose2(points);
                } else {
                    System.out.println("wrong number of points");
                }
                    break;
            case 3 :
                if(judge.numValidate(3,points)) {
                    calculate.choose3(points);
                } else {
                    System.out.println("wrong number of points");
                }
                    break;
            case 4 :
                if(judge.numValidate(4,points)) {
                    calculate.choose4(points);
                } else {
                    System.out.println("wrong number of points");
                }
                    break;
            case 5 :
                if(judge.numValidate(4,points)) {
                    calculate.choose5(points);
                } else {
                    System.out.println("wrong number of points");
                }
                    break;
            default:
                System.out.println("Wrong Format");
            }
        }else {
            System.out.println("Wrong Format");
        }

    }

}

class Judge {
    
    public Judge() {
    }

    public boolean formatValidate(String[] points) {
        Pattern format=Pattern.compile("^([+-]?([0-9]|([1-9][0-9]*)))(\\.\\d+)?,([+-]?([0-9]|([1-9][0-9]*)))(\\.\\d+)?$");
        Matcher matcher;
        boolean validate = true;
        for(int i = 0; i < points.length; i++) {
            matcher = format.matcher(points[i]);
            if(!matcher.matches()) {
                validate = false;
            }
        }
        return validate;
    }
    
    public boolean numValidate(int num, String[] points) {
        boolean validate = true;
        if(points.length > num) {
            validate = false;
        }
        return validate;
    }
}

class Calculate {

    public Calculate() {
    }
    
    public void choose1(String[] points) {
        double x1, y1, x2, y2, k;
        String[] points1 = points[0].split(",");
        String[] points2 = points[1].split(",");
        x1 = Double.parseDouble(points1[0]);
        y1 = Double.parseDouble(points1[1]);
        x2 = Double.parseDouble(points2[0]);
        y2 = Double.parseDouble(points2[1]);
        if(x1 == x2 && y1 == y2) {
            System.out.println("points coincide");
            System.exit(0);
        }
        if(x1 == x2) {
            System.out.println("Slope does not exist");
        }else {
            k = (y2 - y1) / (x2 - x1);
            System.out.println(k);
        }
    }
    
    public void choose2(String[] points) {
        double x1, y1, x2, y2, x3, y3 , l;
        String[] points1 = points[0].split(",");
        String[] points2 = points[1].split(",");
        String[] points3 = points[2].split(",");
        x1 = Double.parseDouble(points1[0]);
        y1 = Double.parseDouble(points1[1]);
        x2 = Double.parseDouble(points2[0]);
        y2 = Double.parseDouble(points2[1]);
        x3 = Double.parseDouble(points3[0]);
        y3 = Double.parseDouble(points3[1]);
        if((x1 == x2 && y1 == y2) || (x1 == x3 && y1 == y3) || (x2 == x3 && y2 == y3)) {
            System.out.println("points coincide");
            System.exit(0);
        }
        if(x2 == x3 && y2 == y3) {
            System.out.println("points coincide");
            System.exit(0);
        }
        l = Math.abs((y1-y2)*x3+(x2-x1)*y3+x1*y2-y1*x2)/Math.sqrt((y1-y2)*(y1-y2) +(x1-x2)*(x1-x2));
        System.out.println(l);
    }
    
    public void choose3(String[] points) {
        double x1, y1, x2, y2, x3, y3;
        String[] points1 = points[0].split(",");
        String[] points2 = points[1].split(",");
        String[] points3 = points[2].split(",");
        x1 = Double.parseDouble(points1[0]);
        y1 = Double.parseDouble(points1[1]);
        x2 = Double.parseDouble(points2[0]);
        y2 = Double.parseDouble(points2[1]);
        x3 = Double.parseDouble(points3[0]);
        y3 = Double.parseDouble(points3[1]);
        if(((y3 - y1 ) * (x2 - x1) - (y2 - y1) * (x3 - x1)) == 0) {
            System.out.println("true");
        }else {
            System.out.println("false");
        }
    }
    
    public void choose4(String[] points) {
        double x1, y1, x2, y2, x3, y3, x4, y4;
        String[] points1 = points[0].split(",");
        String[] points2 = points[1].split(",");
        String[] points3 = points[2].split(",");
        String[] points4 = points[3].split(",");
        x1 = Double.parseDouble(points1[0]);
        y1 = Double.parseDouble(points1[1]);
        x2 = Double.parseDouble(points2[0]);
        y2 = Double.parseDouble(points2[1]);
        x3 = Double.parseDouble(points3[0]);
        y3 = Double.parseDouble(points3[1]);
        x4 = Double.parseDouble(points4[0]);
        y4 = Double.parseDouble(points4[1]);
        if((x1 == x2 && y1 == y2) || (x3 == x4 && y3 == y4)) {
            System.out.println("points coincide");
            System.exit(0);
        }
        if((x1 == x2 && x3 == x4) || (y2 - y1) * (x4 - x3) == (y4 - y3) * (x2 - x1)) {
            System.out.println("true");
        }else {
            System.out.println("false");
        }
    }
    
    public void choose5(String[] points) {
        double x1, y1, x2, y2, x3, y3, x4, y4;
        String[] points1 = points[0].split(",");
        String[] points2 = points[1].split(",");
        String[] points3 = points[2].split(",");
        String[] points4 = points[3].split(",");
        x1 = Double.parseDouble(points1[0]);
        y1 = Double.parseDouble(points1[1]);
        x2 = Double.parseDouble(points2[0]);
        y2 = Double.parseDouble(points2[1]);
        x3 = Double.parseDouble(points3[0]);
        y3 = Double.parseDouble(points3[1]);
        x4 = Double.parseDouble(points4[0]);
        y4 = Double.parseDouble(points4[1]);
        if((x1 == x2 && y1 == y2) || (x3 == x4 && y3 == y4)) {
            System.out.println("points coincide");
            System.exit(0);
        }
        if((x1 == x2 && x3 == x4) || (y2 - y1) * (x4 - x3) == (y4 - y3) * (x2 - x1)) {
            System.out.println("is parallel lines,have no intersection point");
        }else {
                System.out.println("false");
        }
    }
}

 

分析如下：本题我设计了三个类Main、Judge、Calculate。Judge主要是用来判断是否符合要求，Calculate则主要用来运行各个选项。后面我在回过头来看自己的代码，我发现自己的代码可扩展性不高，如果提高扩展性会更好。

 

 

点线形系列迭代

题目说明如下：

类图如下：无

源码如下：

import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.text.DecimalFormat;
public class Main {
    public static void main(String[] args) {
        Control control = new Control();
        control.start();
    }
}
class Control {
    Input input = new Input();
    Judge judge = new Judge();
    Calculate calculate = new Calculate();
    String[] points;
    int choice;
    public Control() {
    }
    public void split() {
        String in = input.input();
        String[] half = in.split(":");
        choice = Integer.valueOf(half[0]);
        points = half[1].split("\\s+");
    }
    public double[][] Points4(String[] points) {
        double x1, y1, x2, y2, x3, y3, x4, y4;
        String[] points1 = points[0].split(",");
        String[] points2 = points[1].split(",");
        String[] points3 = points[2].split(",");
        String[] points4 = points[3].split(",");
        x1 = Double.parseDouble(points1[0]);
        y1 = Double.parseDouble(points1[1]);
        x2 = Double.parseDouble(points2[0]);
        y2 = Double.parseDouble(points2[1]);
        x3 = Double.parseDouble(points3[0]);
        y3 = Double.parseDouble(points3[1]);
        x4 = Double.parseDouble(points4[0]);
        y4 = Double.parseDouble(points4[1]);
        double[][] point = {{x1, y1}, {x2, y2}, {x3, y3}, {x4, y4}};
        return point;
    }
    public double[][] Points5(String[] points) {
        double x1, y1, x2, y2, x3, y3, x4, y4, x5, y5;
        String[] points1 = points[0].split(",");
        String[] points2 = points[1].split(",");
        String[] points3 = points[2].split(",");
        String[] points4 = points[3].split(",");
        String[] points5 = points[4].split(",");
        x1 = Double.parseDouble(points1[0]);
        y1 = Double.parseDouble(points1[1]);
        x2 = Double.parseDouble(points2[0]);
        y2 = Double.parseDouble(points2[1]);
        x3 = Double.parseDouble(points3[0]);
        y3 = Double.parseDouble(points3[1]);
        x4 = Double.parseDouble(points4[0]);
        y4 = Double.parseDouble(points4[1]);
        x5 = Double.parseDouble(points5[0]);
        y5 = Double.parseDouble(points5[1]);
        double[][] point = {{x1, y1}, {x2, y2}, {x3, y3}, {x4, y4},{x5, y5}};
        return point;
    }
    public double[][] Points6(String[] points) {
        double x1, y1, x2, y2, x3, y3, x4, y4, x5, y5, x6, y6;
        String[] points1 = points[0].split(",");
        String[] points2 = points[1].split(",");
        String[] points3 = points[2].split(",");
        String[] points4 = points[3].split(",");
        String[] points5 = points[4].split(",");
        String[] points6 = points[5].split(",");
        x1 = Double.parseDouble(points1[0]);
        y1 = Double.parseDouble(points1[1]);
        x2 = Double.parseDouble(points2[0]);
        y2 = Double.parseDouble(points2[1]);
        x3 = Double.parseDouble(points3[0]);
        y3 = Double.parseDouble(points3[1]);
        x4 = Double.parseDouble(points4[0]);
        y4 = Double.parseDouble(points4[1]);
        x5 = Double.parseDouble(points5[0]);
        y5 = Double.parseDouble(points5[1]);
        x6 = Double.parseDouble(points6[0]);
        y6 = Double.parseDouble(points6[1]);
        double[][] point = {{x1, y1}, {x2, y2}, {x3, y3}, {x4, y4},{x5, y5},{x6, y6}};
        return point;
    }
    public String rounding(double num) {
        String result;
        DecimalFormat df;
        switch(judge.places(num)) {
        case 1 :
            df = new DecimalFormat(".0");
            result = df.format(num);
            break;
        case 2 :
            df = new DecimalFormat(".00");
            result = df.format(num);
            break;
        default :
            df = new DecimalFormat(".000");
            result = df.format(num);
            break;
            }
        return result;
    }
    public void choose1() {
        double[][] point = Points4(points);
        boolean result1 = false,result2 = false;
        judge.coincideValidate(point);
        if(judge.quadrilateral(point)) {
            result1 = true;
            if(judge.parallelogram(point)) {
                result2 = true;
            }
        }
        System.out.println(result1+" "+result2);
    }
    public void choose2() {
        double[][] point = Points4(points);
        boolean result1 = false,result2 = false,result3 = false;
        if(judge.quadrilateral(point)) {
            judge.coincideValidate(point);
            if(judge.diamond(point)) {
                result1 = true;
            }
            if(judge.rectangle(point)) {
                result2 = true;
                if(judge.square(point)) {
                    result3 = true;
                }
            }
            System.out.println(result1+" "+result2+" "+result3);
        }else {
            System.out.println("not a quadrilateral");
        }
    }
    public void choose3() {
        double[][] point = Points4(points);
        boolean result = judge.concavity(point);
        double perimeter,area;
        if(judge.quadrilateral(point)) {
            judge.coincideValidate(point);
            perimeter = Calculate.perimeter(point);
            area = Calculate.area(point[0],point[1],point[2]) + Calculate.area(point[0],point[2],point[3]);
            System.out.println(result+" "+rounding(perimeter)+" "+rounding(area));
        }else {
            System.out.println("not a quadrilateral");
        }
    }
    public void choose4() {
        double[][] point = Points6(points);
        if(judge.joints(point[0],point[1])) {
            System.out.println("points coincide");
            System.exit(0);
        }
        double[][] point1 = {point[0],point[1]};
        double[][] point2 = {point[2],point[3],point[4],point[5]};
        double area1,area2;
        int choice = judge.quadrilateralOrTriangle(point2);
        switch(choice) {
        case 1 :
            double[][] point3 = judge.getAfterPoint(point2);
            if(judge.triangleLinesCoincide(point1, point3)) {
                System.out.println("The line is coincide with one of the lines");
            }
            else if(judge.triangleOneIntersection(point1, point3)) {
                System.out.println("1");
            }else {
                double[][] point4 = judge.triangleIntersection(point1, point3);
                if(point4 == null) {
                    System.out.println("0");
                }else {
                    area1 = Calculate.area(point4[0], point4[1], point4[2]);
                    area2 =  Calculate.area(point3[0], point3[1], point3[2]) - area1;
                    if(area1 < area2) {
                        System.out.println("2 "+rounding(area1)+" "+rounding(area2));
                    }else {
                        System.out.println("2 "+rounding(area2)+" "+rounding(area1));
                    }
                }
            }
            break;
        case 2 :
            if(judge.quadrilateralLinesCoincide(point1, point2)) {
                System.out.println("The line is coincide with one of the lines");
            }
            else if(judge.quadrilateralOneIntersection(point1, point2)) {
                System.out.println("1");
            }else {
                double[][] point5 = judge.quadrilateralIntersection(point1, point2);
                if(point5 == null) {
                    System.out.println("0");
                }else {
                    double area3 = Calculate.area(point2[0], point2[1], point2[2]) + Calculate.area(point2[1], point2[2], point2[3]);
                    if(point5[3] == null) {
                        area1 = Calculate.area(point5[0], point5[1], point5[2]);
                    }else {
                        area1 = Calculate.area(point5[0], point5[1], point5[2]) + Calculate.area(point5[1], point5[2], point5[3]);
                    }
                    area2 =  area3 - area1;
                    if(area1 < area2) {
                        System.out.println("2 "+rounding(area1)+" "+rounding(area2));
                    }else {
                        System.out.println("2 "+rounding(area2)+" "+rounding(area1));
                    }
                }
            }
            break;
        default:
            System.out.println("not a quadrilateral or triangle");
        }
    }
    public void choose5() {
        double[][] point = Points5(points);
        double[] point1 = point[0];
        double[][] point2 = {point[1],point[2],point[3],point[4]};
        switch(judge.quadrilateralOrTriangle(point2)) {
        case 1 :
            double[][] point3 = judge.getAfterPoint(point2);
            judge.placeOfPoint(point1,point3,"triangle");
            break;
        case 2 :
            judge.placeOfPoint(point1,point2,"quadrilateral");
            break;
        default:
            System.out.println("not a quadrilateral or triangle");
        }
    }
    public void start() {
        split();
        if(judge.formatValidate(points)) {
            switch(choice) {
            case 1 :
                if(judge.numValidate(4,points)) {
                    choose1();
                } else {
                    System.out.println("wrong number of points");
                }
                    break;
            case 2 :
                if(judge.numValidate(4,points)) {
                    choose2();
                } else {
                    System.out.println("wrong number of points");
                }
                    break;
            case 3 :
                if(judge.numValidate(4,points)) {
                    choose3();
                } else {
                    System.out.println("wrong number of points");
                }
                    break;
            case 4 :
                if(judge.numValidate(6,points)) {
                    System.out.println("not a quadrilateral or triangle");
                } else {
                    System.out.println("wrong number of points");
                }
                    break;
            case 5 :
                if(judge.numValidate(5,points)) {
                    choose5();
                } else {
                    System.out.println("wrong number of points");
                }
                    break;
            }
        }else {
            System.out.println("Wrong Format");
        }
    }
}
class Judge {
    public Judge() {
    }
    public boolean formatValidate(String[] points) {
        Pattern format=Pattern.compile("^([+-]?([0-9]|([1-9][0-9]*)))(\\.\\d+)?,([+-]?([0-9]|([1-9][0-9]*)))(\\.\\d+)?$");
        Matcher matcher;
        boolean validate = true;
        for(int i = 0; i < points.length; i++) {
            matcher = format.matcher(points[i]);
            if(!matcher.matches()) {
                validate = false;
            }
        }
        return validate;
    }
    public boolean numValidate(int num, String[] points) {
        return points.length == num;
    }
    public boolean joints(double[] p1,double[] p2) {
        return p1[0] == p2[0] && p1[1] == p2[1];
    }
    public void coincideValidate(double[][] point) {
        if(joints(point[0],point[1]) || joints(point[0],point[2]) || joints(point[0],point[3]) || joints(point[1],point[2]) || joints(point[1],point[3]) || joints(point[2],point[3]) ) {
            System.out.println("points coincide");
            System.exit(0);
        }
    }
    public int coincideValidatePlus(double[][] p) {
        int abandonedPoint = -1;
        if(joints(p[0],p[1]) && pointOnLine(p[1],p[2],p[3])) {
            abandonedPoint = 0;
        }
        else if(joints(p[1],p[2]) && pointOnLine(p[2],p[3],p[0])) {
            abandonedPoint = 1;
        }
        else if(joints(p[2],p[3]) && pointOnLine(p[3],p[0],p[1])) {
            abandonedPoint = 2;
        }
        else if(joints(p[3],p[0]) && pointOnLine(p[0],p[1],p[2])) {
            abandonedPoint = 3;
        }
        return abandonedPoint;
    }
    public boolean pointOnLine(double[] p1,double[] p2,double[] p3) {
        double k1 = Calculate.getK(p1,p2);
        double k2 = Calculate.getK(p1,p3);
        return (k1 == k2||((k1 == Double.NEGATIVE_INFINITY && k2 == Double.POSITIVE_INFINITY)||(k2 == Double.NEGATIVE_INFINITY && k1 == Double.POSITIVE_INFINITY)));
    }
    public boolean pointInLine(double[] p1,double[] p2,double[] p3) {
        return pointOnLine(p1,p2,p3)&&((p2[0] >= p1[0] && p2[0] <= p3[0])||(p2[0] <= p1[0] && p2[0] >= p3[0]))&&((p2[1] >= p1[1] && p2[1] <= p3[1])||(p2[1] <= p1[1] && p2[1] >= p3[1]));
    }
    public boolean quadrilateral(double[][] point) { //四边形
        return !pointOnLine(point[0],point[1],point[2])&&!pointOnLine(point[0],point[1],point[3])&&!pointOnLine(point[0],point[2],point[3])&&!pointOnLine(point[1],point[2],point[3]);
    }
    public boolean parallelogram(double[][] point) {
        return (point[0][0]+point[2][0]==point[1][0]+point[3][0] && point[0][1]+point[2][1]==point[1][1]+point[3][1]) ;
    }
    public boolean diamond(double[][] point) {
        return parallelogram(point)&&(Calculate.distance(point[0], point[1]) == Calculate.distance(point[0], point[3]));
    }
    public boolean rectangle(double[][] point) {
        return parallelogram(point)&&(Calculate.distance(point[0], point[2]) == Calculate.distance(point[1], point[3]));
    }
    public boolean square(double[][] point) {
        return rectangle(point)&&(Calculate.distance(point[0], point[1]) == Calculate.distance(point[0], point[3]));
    }
    public boolean concavity(double[][] point) {
        boolean result = false;//凹
        if(Calculate.area(point[0],point[1],point[2]) + Calculate.area(point[0],point[2],point[3]) == Calculate.area(point[1],point[2],point[3]) + Calculate.area(point[0],point[1],point[3])) {
            result = true;//凸
        }
        return result;
    }
    public int places(double num) { //小数位数
        int result = 3;
        DecimalFormat df = new DecimalFormat(".000");
        String a = df.format(num);
        String[] b = a.split("\\.");
        if(b[1].charAt(2) == '0') {
            result = 2;
            if(b[1].charAt(1) == '0') {
                result = 1;
            }
        }
        return result;
    }
    public int quadrilateralOrTriangle(double[][] point) {
        int choice;
        int abandonedPoint = getAbandonedPoint(point);
        if(abandonedPoint != -1) {
            choice = 1;
        }
        else if(quadrilateral(point)) {
            choice = 2;
        }
        else {
            choice = 0;
        }
        return choice;
    }
    public int getAbandonedPoint(double[][] point) {
        int abandonedPoint = -1;
        switch(coincideValidatePlus(point)) {
        case -1 :
            boolean j1 = pointOnLine(point[0],point[1],point[2]);
            boolean j2 = pointOnLine(point[1],point[2],point[3]);
            if(!(j1&&j2)) {//四点不共线
                if(pointInLine(point[0],point[1],point[2])) {
                    abandonedPoint = 1;
                    break;
                }
                else if(pointInLine(point[1],point[2],point[3])) {
                    abandonedPoint = 2;
                    break;
                }
                else if(pointInLine(point[2],point[3],point[0])) {
                    abandonedPoint = 3;
                    break;
                }
                else if(pointInLine(point[3],point[0],point[1])) {
                    abandonedPoint = 0;
                    break;
                }
            }
            break;
        case 0 :
            abandonedPoint = 0;
            break;
        case 1 :
            abandonedPoint = 1;
            break;
        case 2 :
            abandonedPoint = 2;
            break;
        case 3 :
            abandonedPoint = 3;
            break;
        }
        return abandonedPoint;
    }
    public double[][] getAfterPoint(double[][] point){
        int abandonedPoint = getAbandonedPoint(point);
        if (abandonedPoint == 0) {
            double[][] afterPoint  = {point[1],point[2],point[3]};
            return afterPoint;
        } 
        else if (abandonedPoint == 1) {
            double[][] afterPoint  = {point[0],point[2],point[3]};
            return afterPoint;
        }
        else if(abandonedPoint == 2) {
            double[][] afterPoint  = {point[0],point[1],point[3]};
            return afterPoint;
        }
        else if(abandonedPoint == 3) {
            double[][] afterPoint  = {point[0],point[1],point[2]};
            return afterPoint;
        }
        else {
            return null;
        }
    }
    public boolean kIsExit(double[] p1,double[] p2) {
        boolean result = true;
        if(p1[0] == p2[0]) {
            result = false;
        }
        return result;
    }
    public int getSide(double[] p1,double[] p2,double[] p3) { //点在直线上侧或下侧或在直线上
        int result = 0;
        if(kIsExit(p1,p2)) {
            if(Calculate.getK(p1, p2)*p3[0] + Calculate.getB(p1, p2) - p3[1] > 0) { //表达式kx + b - y = 0
                result = 1;//上侧
            }
            else if(Calculate.getK(p1, p2)*p3[0] + Calculate.getB(p1, p2) - p3[1] < 0) { //表达式kx + b - y = 0
                result = 2;//下侧
            }
        } else {
            if(p3[0] < p1[0]) { //表达式kx + b - y = 0
                result = 1;//左侧
            }
            else if(p3[0] > p1[0]) { //表达式kx + b - y = 0
                result = 2;//右侧
            }
        }
        return result;
    }
    public double[] getIntersectPoint(double[] p1, double[] p2, double[] p3, double[] p4){
        double A1=p1[1]-p2[1];
        double B1=p2[0]-p1[0];
        double C1=A1*p1[0]+B1*p1[1];
        double A2=p3[1]-p4[1];
        double B2=p4[0]-p3[0];
        double C2=A2*p3[0]+B2*p3[1];
        double det_k=A1*B2-A2*B1;
        if(Math.abs(det_k)<0.00001){
            return null;
        }
        double a=B2/det_k;
        double b=-1*B1/det_k;
        double c=-1*A2/det_k;
        double d=A1/det_k;
        double x=a*C1+b*C2;
        double y=c*C1+d*C2;
        double[] intersection = {x,y};
        return  intersection;
    }
    public boolean  triangleLinesCoincide(double[][] p1,double[][] p2) {
        return (getSide(p1[0],p1[1],p2[0]) ==0 && getSide(p1[0],p1[1],p2[1]) ==0)||(getSide(p1[0],p1[1],p2[1]) ==0 && getSide(p1[0],p1[1],p2[2]) ==0)||(getSide(p1[0],p1[1],p2[2]) ==0 && getSide(p1[0],p1[1],p2[0]) ==0);
    }
    public boolean  triangleOneIntersection(double[][] p1,double[][] p2) {
        boolean result = false;
        if(getSide(p1[0],p1[1],p2[0]) ==0 && getSide(p1[0],p1[1],p2[1]) == getSide(p1[0],p1[1],p2[2]) && getSide(p1[0],p1[1],p2[1]) !=0){
            result = true;//过点0
        }
        else if(getSide(p1[0],p1[1],p2[1]) ==0 && getSide(p1[0],p1[1],p2[2]) == getSide(p1[0],p1[1],p2[0]) && getSide(p1[0],p1[1],p2[2]) !=0){
            result = true;//过点1
        }
        else if(getSide(p1[0],p1[1],p2[2]) ==0 && getSide(p1[0],p1[1],p2[0]) == getSide(p1[0],p1[1],p2[1]) && getSide(p1[0],p1[1],p2[0]) !=0){
            result = true;//过点2
        }
        return result;
    }
    public double[][] triangleIntersection(double[][] p1,double[][] p2) {
        double[][] intersection = new double[3][2];
        boolean judge = true;
        boolean a1 = false,a2 = false,a3 = false;
        boolean b1 = false,b2 =false,b3 = false;
        if(getSide(p1[0],p1[1],p2[0]) != getSide(p1[0],p1[1],p2[1]) && getSide(p1[0],p1[1],p2[0]) !=0 && getSide(p1[0],p1[1],p2[1]) !=0){
            a1 = true;//与a1交
        }
        if(getSide(p1[0],p1[1],p2[1]) != getSide(p1[0],p1[1],p2[2]) && getSide(p1[0],p1[1],p2[1]) !=0 && getSide(p1[0],p1[1],p2[2]) !=0){
            a2 = true;//与a2交
        }
        if(getSide(p1[0],p1[1],p2[2]) != getSide(p1[0],p1[1],p2[0]) && getSide(p1[0],p1[1],p2[2]) !=0 && getSide(p1[0],p1[1],p2[0]) !=0){
            a3 = true;//与a3交
        }
        if(getSide(p1[0],p1[1],p2[2]) ==0){
            b1 = true;//过点2
        }
        if(getSide(p1[0],p1[1],p2[0]) ==0){
            b2 = true;//过点0
        }
        if(getSide(p1[0],p1[1],p2[1]) ==0){
            b3 = true;//过点1
        }
        if(a1&&b1) {
            intersection[0] = p2[2];
            intersection[1] = getIntersectPoint(p1[0],p1[1],p2[0],p2[1]);
            intersection[2] = p2[0];
        }
        else if(a2&&b2) {
            intersection[0] = p2[0];
            intersection[1] = getIntersectPoint(p1[0],p1[1],p2[1],p2[2]);
            intersection[2] = p2[1];
        }
        else if(a3&&b3) {
            intersection[0] = p2[1];
            intersection[1] = getIntersectPoint(p1[0],p1[1],p2[2],p2[0]);
            intersection[2] = p2[2];
        }
        else if(a1&&a2) {
            intersection[0] = getIntersectPoint(p1[0],p1[1],p2[0],p2[1]);
            intersection[1] = getIntersectPoint(p1[0],p1[1],p2[1],p2[2]);
            intersection[2] = p2[1];
        }
        else if(a1&&a3) {
            intersection[0] = getIntersectPoint(p1[0],p1[1],p2[0],p2[1]);
            intersection[1] = getIntersectPoint(p1[0],p1[1],p2[2],p2[0]);
            intersection[2] = p2[0];
        }
        else if(a2&&a3) {
            intersection[0] = getIntersectPoint(p1[0],p1[1],p2[1],p2[2]);
            intersection[1] = getIntersectPoint(p1[0],p1[1],p2[2],p2[0]);
            intersection[2] = p2[2];
        }
        else {
            judge = false;
        }
        if(judge) {
            return intersection;
        }else {
            return null;
        }
    }
    public boolean quadrilateralLinesCoincide(double[][] p1,double[][] p2) {
        return (getSide(p1[0],p1[1],p2[0]) ==0 && getSide(p1[0],p1[1],p2[1]) ==0)||(getSide(p1[0],p1[1],p2[1]) ==0 && getSide(p1[0],p1[1],p2[2]) ==0)||(getSide(p1[0],p1[1],p2[2]) ==0 && getSide(p1[0],p1[1],p2[3]) ==0)||(getSide(p1[0],p1[1],p2[3]) ==0 && getSide(p1[0],p1[1],p2[0])==0);
    }
    public boolean  quadrilateralOneIntersection(double[][] p1,double[][] p2) {
        boolean result = false;
        if(getSide(p1[0],p1[1],p2[0]) ==0 && getSide(p1[0],p1[1],p2[1]) == getSide(p1[0],p1[1],p2[2]) && getSide(p1[0],p1[1],p2[2]) == getSide(p1[0],p1[1],p2[3]) && getSide(p1[0],p1[1],p2[1]) !=0){
            result = true;//过点0
        }
        else if(getSide(p1[0],p1[1],p2[1]) ==0 && getSide(p1[0],p1[1],p2[2]) == getSide(p1[0],p1[1],p2[3]) && getSide(p1[0],p1[1],p2[3]) == getSide(p1[0],p1[1],p2[0])&& getSide(p1[0],p1[1],p2[2]) !=0){
            result = true;//过点1
        }
        else if(getSide(p1[0],p1[1],p2[2]) ==0 && getSide(p1[0],p1[1],p2[3]) == getSide(p1[0],p1[1],p2[0]) && getSide(p1[0],p1[1],p2[0]) == getSide(p1[0],p1[1],p2[1])&& getSide(p1[0],p1[1],p2[3]) !=0){
            result = true;//过点2
        }
        else if(getSide(p1[0],p1[1],p2[2]) ==0 && getSide(p1[0],p1[1],p2[0]) == getSide(p1[0],p1[1],p2[1]) && getSide(p1[0],p1[1],p2[1]) == getSide(p1[0],p1[1],p2[2])&& getSide(p1[0],p1[1],p2[0]) !=0){
            result = true;//过点3
        }
        return result;
    }
    public double[][] quadrilateralIntersection(double[][] p1,double[][] p2) {
        double[][] intersection = new double[4][2];
        boolean judge = true;
        boolean a1 = false,a2 = false,a3 = false,a4 = false;
        boolean b1 = false,b2 =false,b3 = false,b4 = false;
        if(getSide(p1[0],p1[1],p2[0]) != getSide(p1[0],p1[1],p2[1]) && getSide(p1[0],p1[1],p2[0]) !=0 && getSide(p1[0],p1[1],p2[1]) !=0){
            a1 = true;//与a1交
        }
        if(getSide(p1[0],p1[1],p2[1]) != getSide(p1[0],p1[1],p2[2]) && getSide(p1[0],p1[1],p2[1]) !=0 && getSide(p1[0],p1[1],p2[2]) !=0){
            a2 = true;//与a2交
        }
        if(getSide(p1[0],p1[1],p2[2]) != getSide(p1[0],p1[1],p2[3]) && getSide(p1[0],p1[1],p2[2]) !=0 && getSide(p1[0],p1[1],p2[3]) !=0){
            a3 = true;//与a3交
        }
        if(getSide(p1[0],p1[1],p2[3]) != getSide(p1[0],p1[1],p2[0]) && getSide(p1[0],p1[1],p2[3]) !=0 && getSide(p1[0],p1[1],p2[0]) !=0){
            a4 = true;//与a4交
        }
        if(getSide(p1[0],p1[1],p2[0]) ==0){
            b1 = true;//过点0
        }
        if(getSide(p1[0],p1[1],p2[1]) ==0){
            b2 = true;//过点1
        }
        if(getSide(p1[0],p1[1],p2[2]) ==0){
            b3 = true;//过点2
        }
        if(getSide(p1[0],p1[1],p2[3]) ==0){
            b4 = true;//过点3
        }
        if(b1&&b3) {//点点
            intersection[0] = p2[0];
            intersection[1] = p2[1];
            intersection[2] = p2[2];
            intersection[3] = null;
        }
        else if(b2&&b4) {
            intersection[0] = p2[1];
            intersection[1] = p2[2];
            intersection[2] = p2[3];
            intersection[3] = null;
        }
        else if(b1&&a2) {//点线
            intersection[0] = p2[0];
            intersection[1] = p2[1];
            intersection[2] = getIntersectPoint(p1[0],p1[1],p2[1],p2[2]);
            intersection[3] = null;
        }
        else if(b1&&a3) {
            intersection[0] = p2[0];
            intersection[1] = getIntersectPoint(p1[0],p1[1],p2[2],p2[3]);
            intersection[2] = p2[3];
            intersection[3] = null;
        }
        else if(b2&&a3) {
            intersection[0] = p2[1];
            intersection[1] = p2[2];
            intersection[2] = getIntersectPoint(p1[0],p1[1],p2[2],p2[3]);
            intersection[3] = null;
        }
        else if(b2&&a4) {
            intersection[0] = p2[1];
            intersection[1] = getIntersectPoint(p1[0],p1[1],p2[3],p2[0]);
            intersection[2] = p2[0];
            intersection[3] = null;
        }
        else if(b3&&a4) {
            intersection[0] = p2[2];
            intersection[1] = p2[3];
            intersection[2] = getIntersectPoint(p1[0],p1[1],p2[3],p2[0]);
            intersection[3] = null;
        }
        else if(b3&&a1) {
            intersection[0] = p2[2];
            intersection[1] = getIntersectPoint(p1[0],p1[1],p2[0],p2[1]);
            intersection[2] = p2[1];
            intersection[3] = null;
        }
        else if(b4&&a1) {
            intersection[0] = p2[3];
            intersection[1] = p2[0];
            intersection[2] = getIntersectPoint(p1[0],p1[1],p2[0],p2[1]);
            intersection[3] = null;
        }
        else if(b4&&a2) {
            intersection[0] = p2[3];
            intersection[1] = getIntersectPoint(p1[0],p1[1],p2[1],p2[2]);
            intersection[2] = p2[2];
            intersection[3] = null;
        }
        else if(a1&&a3) {//线线
            intersection[0] = p2[0];
            intersection[1] = getIntersectPoint(p1[0],p1[1],p2[0],p2[1]);
            intersection[2] = getIntersectPoint(p1[0],p1[1],p2[2],p2[3]);
            intersection[3] = p2[3];
        }
        else if(a2&&a4) {
            intersection[0] = p2[0];
            intersection[1] = p2[1];
            intersection[2] = getIntersectPoint(p1[0],p1[1],p2[1],p2[2]);
            intersection[3] = getIntersectPoint(p1[0],p1[1],p2[3],p2[0]);
        }
        else if(a1&&a2) {
            intersection[0] = getIntersectPoint(p1[0],p1[1],p2[0],p2[1]);
            intersection[1] = getIntersectPoint(p1[0],p1[1],p2[1],p2[2]);
            intersection[0] = p2[1];
            intersection[3] = null;
        }
        else if(a2&&a3) {
            intersection[0] = getIntersectPoint(p1[0],p1[1],p2[1],p2[2]);
            intersection[1] = getIntersectPoint(p1[0],p1[1],p2[2],p2[3]);
            intersection[0] = p2[2];
            intersection[3] = null;
        }
        else if(a3&&a4) {
            intersection[0] = getIntersectPoint(p1[0],p1[1],p2[2],p2[3]);
            intersection[1] = getIntersectPoint(p1[0],p1[1],p2[3],p2[0]);
            intersection[0] = p2[3];
            intersection[3] = null;
        }
        else if(a4&&a1) {
            intersection[0] = getIntersectPoint(p1[0],p1[1],p2[3],p2[0]);
            intersection[1] = getIntersectPoint(p1[0],p1[1],p2[0],p2[1]);
            intersection[0] = p2[3];
            intersection[3] = null;
        }
        else {
            judge = false;
        }
        if(judge) {
            return intersection;
        }else {
            return null;
        }
    }
    public boolean pointAndLine(double[] p1, double[] p2,double[] p3,String name,boolean result) {
        if(pointInLine(p1, p2, p3)){
            System.out.println("on the "+name);
            System.exit(0);
        }
        double v = (p3[1] - p1[1]) * (p2[0] - p1[0]) / (p2[1] - p1[1]);
        if (p1[1] < p3[1] && p2[1] >= p3[1]) {
            double x = p1[0] + v;
            if (x > p3[0]) {
                result = !result;
            }
        } else if (p1[1] >= p3[1] && p2[1] < p3[1]) {
            double x = p1[0] + v;
            if (x > p3[0]) {
                result = !result;
            }
        }
        return result;
    }
    public void placeOfPoint(double[] p1, double[][] p2,String name) {
        boolean result = false;
        if(name.equals("triangle")) {
            result = pointAndLine(p2[0],p2[1],p1,name,result);
            result = pointAndLine(p2[1],p2[2],p1,name,result);
            result = pointAndLine(p2[2],p2[0],p1,name,result);
        }else {
            result = pointAndLine(p2[0],p2[1],p1,name,result);
            result = pointAndLine(p2[1],p2[2],p1,name,result);
            result = pointAndLine(p2[2],p2[3],p1,name,result);
            result = pointAndLine(p2[3],p2[0],p1,name,result);
        }
        if (result) {
            System.out.println("in the " + name);
        } else {
            System.out.println("outof the " + name);
        }
    }
}
class Calculate {
    public Calculate() {
    }
    public static double getK(double[] p1,double[] p2) {
        return (p2[1] - p1[1]) / (p2[0] - p1[0]);
    }
    public static double getB(double[] p1,double[] p2) {
        return p1[1] - (p2[1] - p1[1]) / (p2[0] - p1[0]) * p1[0];
    }
    public static double distance(double[] p1,double[] p2) {
        return Math.sqrt((p2[1]-p1[1])*(p2[1]-p1[1]) + (p2[0]-p1[0])*(p2[0]-p1[0]));
    }
    public static double area(double[] p1,double[] p2,double[] p3) {
        double a = distance(p1,p2);
        double b = distance(p1,p3);
        double c = distance(p2,p3);
        double p = (a + b + c) /2;
        return Math.sqrt(p*(p-a)*(p-b)*(p-c));
    }
    public static double perimeter(double[][] p) {
        double a = distance(p[0],p[1]);
        double b = distance(p[1],p[2]);
        double c = distance(p[2],p[3]);
        double d = distance(p[3],p[0]);
        return a+b+c+d;
    }
}
class Input {
    public Input() {
    }
    public String input() {
        Scanner in = new Scanner(System.in);
        String input = in.nextLine();
        return input;
    }
}

分析如下：这题有些难度，我花费了很多时间最后也只得了82分。虽然题目看起来这里只有简单的五个选项，但后面两个选项非常复杂，需要写很多代码，进行很多判断和分情况。前面三个选项还好，但是有几个我一直过不了，应该是一些细节没有设计好。我此处只设计五个类Main、Judge、Control、Calculate、Input。Judge主要用来判断和分类各种情况以及不符合规范的输入，Control则用来执行五个选项，Calculate用来为Judge和Control提供一些设计好的计算方法，Input则用来接收用户的输入。

OOP期中考试分析

第一题:

题目说明如下：

 

类图如下：

源码如下：

 

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        double[] points =new double[4];
        String color;
        for(int i = 0;i < 4;i++) {
            points[i] = in.nextDouble();
            if(points[i]<=0||points[i]>200) {
                System.out.println("Wrong Format");
                System.exit(0);
            }
        }
        color = in.next();
        Point point1 = new Point(points[0],points[1]);
        Point point2 = new Point(points[2],points[3]);
        Line line = new Line(point1,point2,color);
        line.display();
    }

}

class Point {
    private double x;
    private double y;
    
    public Point() {
    }

    public Point(double x, double y) {
        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.println("("+String.format("%.2f", x)+","+String.format("%.2f", y)+")");
    }
}

class Line {
    private Point point1 = new Point();
    private Point point2 = new Point();
    private String color;
    
    public Line() {
    }

    public Line(Point p1, Point p2, String color) {
        this.point1 = p1;
        this.point2 = p2;
        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 d1 = point2.getY() - point1.getY();
        double d2 = point2.getX() - point1.getX();
        return Math.sqrt(d1*d1+d2*d2);
    }
    
    public void display() {
        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.println("The line's length is:"+String.format("%.2f", getDistance()));
    }
}

 

分析如下：本题主要考察对于类间关系的理解以及String.format("%.2f", data)保留小数输出的方法

第二题：

题目说明如下：

 

类图如下：

 

 源码如下：

 

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        double[] points =new double[4];
        String color;
        for(int i = 0;i < 4;i++) {
            points[i] = in.nextDouble();
            if(points[i]<=0||points[i]>200) {
                System.out.println("Wrong Format");
                System.exit(0);
            }
        }
        color = in.next();
        Element plane = new Plane(color);
        Point point1 = new Point(points[0],points[1]);
        Point point2 = new Point(points[2],points[3]);
        Element line = new Line(point1,point2,color);
        point1.display();
        point2.display();
        line.display();
        plane.display();
    }

}

abstract class Element {

    public Element() {
    }

    public abstract void display();
    
}

class Point extends Element{
    private double x;
    private double y;
    
    public Point() {
        super();
    }

    public Point(double x, double y) {
        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() {
        System.out.println("("+String.format("%.2f", x)+","+String.format("%.2f", y)+")");
    }
}

class Line extends Element{
    private Point point1 = new Point();
    private Point point2 = new Point();
    private String color;
    
    public Line() {
        super();
    }

    public Line(Point p1, Point p2, String color) {
        super();
        this.point1 = p1;
        this.point2 = p2;
        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 d1 = point2.getY() - point1.getY();
        double d2 = point2.getX() - point1.getX();
        return Math.sqrt(d1*d1+d2*d2);
    }
    
    @Override
    public void display() {
        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.println("The line's length is:"+String.format("%.2f", getDistance()));
    }
}

class Plane extends Element{
    private String color;

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

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

 

分析如下：本题主要考察继承与多态的运用以及对抽象类的理解，但同时要记住别忘了对各个类的属性进行封装。

第三题：

题目说明如下：

类图如下：

 

 

 源码如下：

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

public class Main {

    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        GeometryObject list = new GeometryObject();
        int choice = input.nextInt();
        while(choice != 0) {
            switch(choice) {
            case 1://insert Point object into list 
                double x = input.nextDouble();
                double y = input.nextDouble();
                list.add(new Point(x,y));
                break;
            case 2://insert Line object into list
                double x1 = input.nextDouble();
                double y1 = input.nextDouble();
                double x2 = input.nextDouble();
                double y2 = input.nextDouble();
                String color = input.next();
                Element line = new Line(new Point(x1,y1),new Point(x2,y2),color);
                list.add(line);
                break;
            case 3://insert Plane object into list
                color = input.next();
                Element plane = new Plane(color);
                list.add(plane);
                break;
            case 4://delete index - 1 object from list
                int index = input.nextInt();
                if(index <= list.getList().size()) {
                    list.remove(index);
                }
                break;
            }
            choice = input.nextInt();
        }
        for(int i = 0;i < list.getList().size();i++) {
            list.getList().get(i).display();
        }
    }
}

abstract class Element {

    public Element() {
    }

    public abstract void display();
    
}

class Point extends Element{
    private double x;
    private double y;
    
    public Point() {
        super();
    }

    public Point(double x, double y) {
        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() {
        System.out.println("("+String.format("%.2f", x)+","+String.format("%.2f", y)+")");
    }
}

class Line extends Element{
    private Point point1 = new Point();
    private Point point2 = new Point();
    private String color;
    
    public Line() {
        super();
    }

    public Line(Point p1, Point p2, String color) {
        super();
        this.point1 = p1;
        this.point2 = p2;
        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 d1 = point2.getY() - point1.getY();
        double d2 = point2.getX() - point1.getX();
        return Math.sqrt(d1*d1+d2*d2);
    }
    
    @Override
    public void display() {
        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.println("The line's length is:"+String.format("%.2f", getDistance()));
    }
}

class Plane extends Element{
    private String color;

    public Plane() {
        super();
    }
    
    public Plane(String color) {
        super();
        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 GeometryObject() {
    }

    public void add(Element element) {
        list.add(element);
    }
    
    public void remove(int index) {
        list.remove(index-1);
    }
    
    public ArrayList<Element> getList(){
        return list;
    }
    
}

分析如下：本题主要考察对于ArrayList的运用和对象创建的理解。对象创建时不积极也要定义，也要new一个新的对象。而ArrayList中remove操作主要要注意不能超过其长度。

踩坑心得

　　在这次几次作业中，我深刻得认识到——自己的思维仍然是c语言的思维而不是OOP的思维，每次拿到一个题目就急着去做而不是一开始就进行类设计。这样做的后果是我没有深刻理解用户需求和题目含义，导致本想节省时间，结果却会花更多的时间。同时，在编写程序时也会顾此失彼，找不到解决和前进的方向。

内容总结：

 　　从这几次的题目中，很明显能看出难度想较前几个星期有很大地提升，不像以前仅仅是对于语法的考察，尤其是蔡柯老师的题目。这就需要花费很多时间，而不是像以前一样在后几天才开始分析。同时，掌握OOP思维才是解题的关键，而不是痴迷于对语法的研究。语法固然重要，但设计思维更为重要。