OO第二次博客作业

前言：

        这段期间主要学习了正则表达式的使用，类设计。

        这段期间设计的题量较大，图形相关的类设计难度较大。

 

 

 

 

 

import java.math.BigDecimal;
import java.util.*;

/**
 * @author LeGend
 */
public class Main {
    static Scanner input = new Scanner(System.in);

    public static void main(String[] args) {
        Client client = new Client();
    }
}

class Client {
    private final HashMap<String, AutomatedTellerMachine> ATMs = new HashMap<>();
    private final ArrayList<User> users = new ArrayList<>();

    public Client() {
        ATMs.put("01", new AutomatedTellerMachine("01", CCB.getInstance()));
        ATMs.put("02", new AutomatedTellerMachine("02", CCB.getInstance()));
        ATMs.put("03", new AutomatedTellerMachine("03", CCB.getInstance()));
        ATMs.put("04", new AutomatedTellerMachine("04", CCB.getInstance()));
        ATMs.put("05", new AutomatedTellerMachine("05", ICBC.getInstance()));
        ATMs.put("06", new AutomatedTellerMachine("06", ICBC.getInstance()));

        users.add(new User("杨过"));
        users.get(0).addAccount(CCB.getInstance().createAccount(users.get(0).getName(), "3217000010041315709"));
        users.get(0).addCard(CCB.getInstance().createCard(users.get(0).getAccount(0),
                "6217000010041315709", "88888888"));
        users.get(0).addCard(CCB.getInstance().createCard(users.get(0).getAccount(0),
                "6217000010041315715", "88888888"));
        users.get(0).getAccount(0).deposit("10000.00");
        users.get(0).addAccount(CCB.getInstance().createAccount(users.get(0).getName(), "3217000010041315715"));
        users.get(0).addCard(CCB.getInstance().createCard(users.get(0).getAccount(1),
                "6217000010041315718", "88888888"));
        users.get(0).getAccount(1).deposit("10000.00");

        users.add(new User("郭靖"));
        users.get(1).addAccount(CCB.getInstance().createAccount(users.get(1).getName(), "3217000010051320007"));
        users.get(1).addCard(CCB.getInstance().createCard(users.get(1).getAccount(0),
                "6217000010051320007", "88888888"));
        users.get(1).getAccount(0).deposit("10000.00");

        users.add(new User("张无忌"));
        users.get(2).addAccount(ICBC.getInstance().createAccount(users.get(2).getName(), "3222081502001312389"));
        users.get(2).addCard(CCB.getInstance().createCard(users.get(2).getAccount(0),
                "6222081502001312389", "88888888"));
        users.get(2).getAccount(0).deposit("10000.00");
        users.get(2).addAccount(ICBC.getInstance().createAccount(users.get(2).getName(), "3222081502001312390"));
        users.get(2).addCard(CCB.getInstance().createCard(users.get(2).getAccount(1),
                "6222081502001312390", "88888888"));
        users.get(2).getAccount(1).deposit("10000.00");
        users.get(2).addAccount(ICBC.getInstance().createAccount(users.get(2).getName(), "3222081502001312399"));
        users.get(2).addCard(CCB.getInstance().createCard(users.get(2).getAccount(2),
                "6222081502001312399", "88888888"));
        users.get(2).addCard(CCB.getInstance().createCard(users.get(2).getAccount(2),
                "6222081502001312400", "88888888"));
        users.get(2).getAccount(2).deposit("10000.00");

        users.add(new User("韦小宝"));
        users.get(3).addAccount(ICBC.getInstance().createAccount(users.get(3).getName(), "3222081502051320785"));
        users.get(3).addCard(CCB.getInstance().createCard(users.get(2).getAccount(0),
                "6222081502051320785", "88888888"));
        users.get(3).getAccount(0).deposit("10000.00");
        users.get(3).addAccount(ICBC.getInstance().createAccount(users.get(3).getName(), "3222081502051320786"));
        users.get(3).addCard(CCB.getInstance().createCard(users.get(3).getAccount(1),
                "6222081502051320786", "88888888"));
        users.get(3).getAccount(1).deposit("10000.00");


        String str;
        do {
            str = Main.input.nextLine();
            if ("#".equals(str)) {
                break;
            }
            String[] strings = str.split(" +");

            if (strings.length == 4) {

                String num = strings[0];
                String password = strings[1];
                String atm = strings[2];
                String amount = strings[3];

                AutomatedTellerMachine automatedTellerMachine = ATMs.get(atm);
                if (automatedTellerMachine == null) {
                    System.out.println("Sorry,the ATM's id is wrong.");
                    System.exit(0);
                } else {
                    if (Double.parseDouble(amount) < 0) {
                        StringBuffer stringBuffer = new StringBuffer(amount);
                        stringBuffer.deleteCharAt(0);
                        automatedTellerMachine.deposit(num, password, stringBuffer.toString());
                    } else {
                        automatedTellerMachine.withdraw(num, password, amount);
                    }
                }
            } else {
                System.out.println("¥" + ChinaUnionPay.getInstance().getCard(strings[0]).getBankAccount().getBalance());
            }
        } while (!"#".equals(str));

    }


}

class User {
    private String name;
    private final ArrayList<BankAccount> bankAccount = new ArrayList<>();
    private final ArrayList<Card> cards = new ArrayList<>();

    public User(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

    public void addAccount(BankAccount bankAccount) {
        this.bankAccount.add(bankAccount);
    }

    public void addCard(Card card) {
        this.cards.add(card);
    }

    public Card getCard(int index) {
        return cards.get(index);
    }

    public BankAccount getAccount(int index) {
        return bankAccount.get(index);
    }

}

class ChinaUnionPay {
    private static ChinaUnionPay chinaUnionPay = null;
    private final HashMap<String, Card> cardNum = new HashMap<>();
    //卡号 和 卡

    private ChinaUnionPay() {
    }

    public static ChinaUnionPay getInstance() {
        if (chinaUnionPay == null) {
            chinaUnionPay = new ChinaUnionPay();
        }
        return chinaUnionPay;
    }

    public void createCard(Card card) {
        this.cardNum.put(card.getAccount(), card);
    }

    public boolean verify(String account, String password) {
        return this.cardNum.get(account).verify(password);
    }

    public Card getCard(String cardNum) {
        return this.cardNum.get(cardNum);
    }

}

class Card {
    private final String account;
    private String password;
    private final BankAccount bankAccount;
    private final String bank;

    public Card(String account, String password, BankAccount bankAccount, String bank) {
        this.account = account;
        this.password = password;
        this.bankAccount = bankAccount;
        this.bank = bank;
    }

    public String getBank() {
        return bank;
    }

    public boolean verify(String password) {
        return password.equals(this.password);
    }

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

    public String getAccount() {
        return account;
    }

    public BankAccount getBankAccount() {
        return bankAccount;
    }


    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (!(o instanceof Card)) {
            return false;
        }

        Card card = (Card) o;

        return getAccount() != null ? getAccount().equals(card.getAccount()) : card.getAccount() == null;
    }

    @Override
    public int hashCode() {
        return getAccount() != null ? getAccount().hashCode() : 0;
    }
}

class AutomatedTellerMachine {
    private final String number;
    private final Bank bank;

    public AutomatedTellerMachine(String number, Bank bank) {
        this.number = number;
        this.bank = bank;
    }

    public String getNumber() {
        return number;
    }

    public void deposit(String cardNumber, String password, String amount) {
        Card card = ChinaUnionPay.getInstance().getCard(cardNumber);
        if (card == null) {
            System.out.println("Sorry,this card does not exist.");
        } else {
            deposit(card, password, amount);
        }
    }

    public void deposit(Card card, String password, String amount) {
        if (!card.getBank().equals(this.bank.getBank())) {
            System.out.println("Sorry,cross-bank withdrawal is not supported.");
            System.exit(0);
        }
        if (!card.verify(password)) {
            System.out.println("Sorry,your password is wrong.");
            System.exit(0);
        } else {
            card.getBankAccount().deposit(amount);
            System.out.println(card.getBankAccount().getName() + "在" + bank.getBank()
                    + "的" + number + "号ATM机上存款¥" + amount + "\n" +
                    "当前余额为¥" + card.getBankAccount().getBalance());

        }
    }

    public void withdraw(String cardNumber, String password, String amount) {
        Card card = ChinaUnionPay.getInstance().getCard(cardNumber);
        if (card == null) {
            System.out.println("Sorry,this card does not exist.");
        } else {
            withdraw(card, password, amount);
        }
    }

    public void withdraw(Card card, String password, String amount) {
        if (!card.getBank().equals(this.bank.getBank())) {
            System.out.println("Sorry,cross-bank withdrawal is not supported.");
            System.exit(0);
        }
        if (!card.verify(password)) {
            System.out.println("Sorry,your password is wrong.");
            System.exit(0);
        } else {
            if (card.getBankAccount().withdraw(amount)) {
                System.out.println(card.getBankAccount().getName() + "在" + bank.getBank()
                        + "的" + number + "号ATM机上取款¥" + amount + "\n" +
                        "当前余额为¥" + card.getBankAccount().getBalance());
            } else {
                System.out.println("Sorry,your account balance is insufficient.");

            }
        }
    }

    public void checkBalance(Card card, String password) {
        if (!card.verify(password)) {
            System.out.println("Sorry,your password is wrong.");
        } else {
            System.out.println("¥" + card.getBankAccount().getBalance());
        }
    }

}

abstract class Bank {
    private final String bank;
    private final HashMap<String, BankAccount> accountList;

    public Bank(String bank) {
        this.bank = bank;
        this.accountList = new HashMap<>();
    }

    public String getBank() {
        return bank;
    }

    public BankAccount createAccount(String name, String account) {
        if (accountList.containsKey(account)) {
            return null;
        } else {
            BankAccount bankAccount = new BankAccount(name, bank, account);
            accountList.put(account, bankAccount);
            return bankAccount;
        }
    }

    //0为成功创建，1为卡号被占用
    public Card createCard(BankAccount bankAccount, String cardAccount, String password) {
        if (ChinaUnionPay.getInstance().getCard(cardAccount) == null) {
            return bankAccount.createCard(cardAccount, password);
        } else {
            return null;
        }

    }

}

class CCB extends Bank {
    private static CCB ccb = null;

    private CCB() {
        super("中国建设银行");
    }

    public static CCB getInstance() {
        if (ccb == null) {
            ccb = new CCB();
        }
        return ccb;
    }

}

class ICBC extends Bank {
    private static ICBC icbc = null;

    private ICBC() {
        super("中国工商银行");
    }

    public static ICBC getInstance() {
        if (icbc == null) {
            icbc = new ICBC();
        }
        return icbc;
    }
}

class BankAccount {
    private BigDecimal balance;
    private final String name;
    private final HashMap<String, Card> card = new HashMap<>();
    //卡号和密码

    private final String account;
    //银行账号

    private final String bank;
    //开卡银行

    public BankAccount(String name, String bank, String account) {
        this.name = name;
        this.bank = bank;
        this.account = account;
        this.balance = new BigDecimal(0);
    }

    public String getName() {
        return name;
    }

    public String getBank() {
        return bank;
    }

    public Card createCard(String cardNumber, String password) {
        Card card = new Card(cardNumber, password, this, this.bank);
        ChinaUnionPay.getInstance().createCard(card);
        this.card.put(cardNumber, card);
        return card;
    }

    public String getBalance() {
        return balance.setScale(2).toString();
    }

    public void deposit(String num) {
        balance = balance.add(new BigDecimal(num));
    }

    public boolean withdraw(String num) {
        BigDecimal temp = new BigDecimal(num);
        temp = temp.abs();
        if (temp.compareTo(balance) > 0) {
            return false;
        } else {
            balance = balance.subtract(temp);
            return true;
        }
    }
}

 

 

 

 

 

 

 

 

 

 

 ATM机的题目尽可能做好了类设计，尽可能降低了耦合性，为之后的扩展打好基础。

 

双向链表：

 

 

 

目前阶段，双向链表不支持迭代器，只能通过单向链表相同的通过循环的方式获取链表中存储的数据。

 

 

 

软件工程专业期中考试（OOP）：

 

 

 

import java.util.Scanner;

/**
 * @author LeGend
 * @date 2022/4/26 19:31
 */
public class Main {
    public static Scanner in = new Scanner(System.in);

    public static void main(String[] args) {
        double x1 = in.nextDouble(), y1 = in.nextDouble(), x2 = in.nextDouble(), y2 = in.nextDouble();
        String color = in.next();

        check(x1);
        check(y1);
        check(x2);
        check(y2);

        Line line = new Line(new Point(x1, y1), new Point(x2, y2), color);
        line.display();

    }

    public static void check(double a) {
        if (a <= 0 || a > 200) {
            System.out.println("Wrong Format");
            System.exit(0);
        }
    }

}

class Point {
    private double x, 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.printf("(%s,%s)", String.format("%.2f", x), String.format("%.2f", y));
    }

}

class Line {
    private Point point1;
    private Point point2;
    private String color;

    public Line() {
    }

    public Line(Point point1, Point point2, String color) {
        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));
    }

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

}

 

 

 

 

 

这道题目属于比较简单的题目，主要体现面向对象原则中三大特性的封装性，通过getter 和 setter 访问类中的数据

 

 

 

 

import java.util.Scanner;

/**
 * @author LeGend
 * @date 2022/4/26 19:31
 */
public class Main {
    public static Scanner in = new Scanner(System.in);

    public static void main(String[] args) {
        double x1 = in.nextDouble(), y1 = in.nextDouble(), x2 = in.nextDouble(), y2 = in.nextDouble();
        String color = in.next();

        check(x1);
        check(y1);
        check(x2);
        check(y2);

        Point point1 = new Point(x1, y1);
        Point point2 = new Point(x2, y2);

        Line line = new Line(point1, point2, color);
        Plane plane = new Plane(color);

        Element element;

        element = point1;//起点Point
        element.display();

        element = point2;//终点Point
        element.display();

        element = line;//线段
        element.display();

        element = plane;//面
        element.display();
        

    }

    public static void check(double a) {
        if (a <= 0 || a > 200) {
            System.out.println("Wrong Format");
            System.exit(0);
        }
    }

}

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

class Point extends Element {
    private double x, 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;
    }

    @Override
    public void display() {
        System.out.printf("(%s,%s)\n", String.format("%.2f", x), String.format("%.2f", y));
    }

}

class Line extends Element {
    private Point point1;
    private Point point2;
    private String color;

    public Line() {
    }

    public Line(Point point1, Point point2, String color) {
        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() {
        System.out.println("The line's color is:" + this.color);
        System.out.println("The line's begin point's Coordinate is:");
        this.point1.display();

        System.out.println("The line's end point's Coordinate is:");
        this.point2.display();

        System.out.println("The line's length is:" + String.format("%.2f", this.getDistance()));
    }
}

class Plane extends Element {
    private String color;

    public Plane() {
    }

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

    public String getColor() {
        return color;
    }

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

    @Override
    public void display() {
        System.out.printf("The Plane's color is:%s", this.color);
    }
}

 

 

 

题目主要通过调用Line 与 Point共同的父类Element中的虚方法display来实现多态。

 

 

 

 

 

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

/**
 * @author LeGend
 * @date 2022/4/26 19:31
 */
public class Main {
    public static Scanner in = new Scanner(System.in);

    public static void main(String[] args) {
        GeometryObject geometryObject = new GeometryObject();

        int choice = in.nextInt();
        while (choice != 0) {
            switch (choice) {
                case 1://insert Point object into list 
                    double x = in.nextDouble(), y = in.nextDouble();
                    check(x);
                    check(y);
                    geometryObject.add(new Point(x, y));
                    break;
                case 2://insert Line object into list
                    double x1 = in.nextDouble();
                    double y1 = in.nextDouble();
                    double x2 = in.nextDouble();
                    double y2 = in.nextDouble();
                    String color2 = in.next();
                    check(x1);
                    check(y1);
                    check(x2);
                    check(y2);
                    geometryObject.add(new Line(new Point(x1, y1), new Point(x2, y2), color2));
                    break;
                case 3://insert Plane object into list
                    String color3 = in.next();
                    geometryObject.add(new Plane(color3));
                    break;
                case 4://delete index - 1 object from list
                    int index = in.nextInt();
                    geometryObject.remove(index);
                    break;
                default:
                    System.out.println("Wrong Format");
            }
            choice = in.nextInt();
        }


        for (Element element : geometryObject.getList()) {
            element.display();
        }

    }

    public static void check(double a) {
        if (a <= 0 || a > 200) {
            System.out.println("Wrong Format");
            System.exit(0);
        }
    }

}

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

class Point extends Element {
    private double x, 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;
    }

    @Override
    public void display() {
        System.out.printf("(%s,%s)\n", String.format("%.2f", x), String.format("%.2f", y));
    }

}

class Line extends Element {
    private Point point1;
    private Point point2;
    private String color;

    public Line() {
    }

    public Line(Point point1, Point point2, String color) {
        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() {
        System.out.println("The line's color is:" + this.color);
        System.out.println("The line's begin point's Coordinate is:");
        this.point1.display();

        System.out.println("The line's end point's Coordinate is:");
        this.point2.display();

        System.out.println("The line's length is:" + String.format("%.2f", this.getDistance()));
    }
}

class Plane extends Element {
    private String color;

    public Plane() {
    }

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

    public String getColor() {
        return color;
    }

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

    @Override
    public void display() {
        System.out.printf("The Plane's color is:%s\n", this.color);
    }
}

class GeometryObject {
    private final ArrayList<Element> list = new ArrayList<>();

    public GeometryObject() {
    }

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

    public void remove(int index) {
        if (index <= list.size() && index > 0) {
            list.remove(index - 1);
        }
    }

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

 

 

 

通过容器类存储数据并读取。

 

 

 

点线形题目

 

 

 

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.Scanner;

import static java.math.MathContext.DECIMAL128;
import static java.math.MathContext.UNLIMITED;

/**
 * @author LeGend
 */
public class Main {
    public static Scanner in = new Scanner(System.in);

    public static boolean cmp(Double a, double b) {
        return Math.abs(a - b) < 1e-6;
    }

    public static void main(String[] args) {
        String temp = in.nextLine();
        if (!temp.contains(":")) {
            System.out.println("Wrong Format");
            return;
        }
        String[] strings = temp.split("([:]| )");
        boolean first = true;
        for (String s : strings) {
            if ("".equals(s)) {
                System.out.println("Wrong Format");
                System.exit(0);
            }
        }
        final int[] check = {0, 4, 4, 4, 6, 5};
        int choice = strings[0].charAt(0) - '0';
        if (check[choice] != strings.length - 1) {
            System.out.print("wrong number of points");
            System.exit(0);
        }
        try {
            switch (Integer.parseInt(strings[0])) {
                case 1:
                    Rectangle rectangle1 = new Rectangle(Point.create(strings[1]), Point.create(strings[2]), Point.create(strings[3]), Point.create(strings[4]));
                    rectangle1.checkRepeat();
                    rectangle1.option1();
                    break;
                case 2:
                    Rectangle rectangle2 = new Rectangle(Point.create(strings[1]), Point.create(strings[2]), Point.create(strings[3]), Point.create(strings[4]));
                    rectangle2.checkRepeat();
                    rectangle2.option2();
                    break;
                case 3:
                    Rectangle rectangle3 = new Rectangle(Point.create(strings[1]), Point.create(strings[2]), Point.create(strings[3]), Point.create(strings[4]));
                    rectangle3.checkRepeat();
                    rectangle3.option3();
                    break;
                case 4:
                    Line line4 = new Line(Point.create(strings[1]), Point.create(strings[2]));
                    Rectangle rectangle4 = new Rectangle(Point.create(strings[3]), Point.create(strings[4]), Point.create(strings[5]), Point.create(strings[6]));
                    Shape shape4 = rectangle4.toShape();
                    shape4.option4(line4);
                    break;
                case 5:
                    Point point5 = Point.create(strings[1]);
                    Rectangle rectangle5 = new Rectangle(Point.create(strings[2]), Point.create(strings[3]), Point.create(strings[4]), Point.create(strings[5]));
                    Shape shape5 = rectangle5.toShape();
                    shape5.option5(point5);
                    break;
                default:
                    System.out.println("Wrong Format");
            }
        } catch (java.lang.NumberFormatException c) {
            System.out.println("Wrong Format");
            System.exit(0);
        }
    }


    public static String round(double val) {
        BigDecimal bigDecimal = new BigDecimal(val);
        bigDecimal = bigDecimal.setScale(3, RoundingMode.HALF_UP);
        bigDecimal = bigDecimal.stripTrailingZeros();
        String ret = bigDecimal.toPlainString();
        if (!ret.contains(".")) {
            ret += ".0";
        }
        return ret;
    }
}

abstract class Shape {
    public abstract void option4(Line line);

    public abstract void option5(Point point);
}

class Point extends Shape {
    private double x, y;

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

    public Point(String s) {
        this.x = x;
        this.y = y;
    }

    public static boolean check(String str) {
        boolean symbol = str.charAt(0) < '0' || str.charAt(0) > '9';

        int temp = str.indexOf('.');
        if (temp == str.length() - 1) {
            System.out.println("Wrong Format");
            System.exit(0);
        }

        StringBuilder stringBuilder = new StringBuilder();

        if (!symbol) {
            stringBuilder.append("+");
        }

        stringBuilder.append(str);

        boolean floatNum = str.contains(".");
        if (floatNum) {//当前字为浮点数
            BigDecimal num = new BigDecimal(str);
            StringBuilder numStr = new StringBuilder();
            if (num.compareTo(BigDecimal.valueOf(0)) > 0) {
                numStr.append("+");
            }

            numStr.append(num);
            if (stringBuilder.toString().equals(numStr.toString())) {
                return true;
            } else {
                return Double.parseDouble(str) == (int) Double.parseDouble(str);
            }

        } else {
            int num = Integer.parseInt(stringBuilder.toString());
            StringBuilder numStr = new StringBuilder();
            if (num >= 0) {
                numStr.append("+");
            }
            numStr.append(num);
            return stringBuilder.toString().equals(numStr.toString());

        }
    }

    public static Point create(String x) {
        String[] tmp = x.split(",");
        try {
            if (tmp.length != 2 || (!(check(tmp[0]) && check(tmp[1])))) {
                System.out.println("Wrong Format");
                System.exit(0);
            }

            return new Point(Double.parseDouble(tmp[0]), Double.parseDouble(tmp[1]));
        } catch (NumberFormatException | ArrayIndexOutOfBoundsException c) {
            System.out.println("Wrong Format");
            System.exit(0);
        }
        return null;
    }

    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 boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }

        Point point = (Point) o;

        if (Double.compare(point.getX(), getX()) != 0) {
            return false;
        }
        return Double.compare(point.getY(), getY()) == 0;
    }

    @Override
    public int hashCode() {
        int result;
        long temp;
        temp = Double.doubleToLongBits(getX());
        result = (int) (temp ^ (temp >>> 32));
        temp = Double.doubleToLongBits(getY());
        result = 31 * result + (int) (temp ^ (temp >>> 32));
        return result;
    }

    public double distance(Point point) {
        return Math.sqrt(Math.pow(this.x - point.x, 2) + Math.pow(this.y - point.y, 2));
    }


    @Override
    public void option4(Line line) {

    }

    @Override
    public void option5(Point point) {

    }
}

class Line {
    private Point point0;
    private Point point1;
    private double k;
    private double c;
    private double length;

    public Line() {
    }

    public Line(Point point0, Point point1) {
        if (point0.equals(point1)) {
            System.out.println("points coincide");
            System.exit(0);
        }
        this.point0 = point0;
        this.point1 = point1;
        k = (point0.getY() - point1.getY()) / (point0.getX() - point1.getX());
        c = point0.getY() - k * point0.getX();
        length = point0.distance(point1);
    }

    public Point getPoint0() {
        return point0;
    }

    public Point getPoint1() {
        return point1;
    }

    public double getK() {
        return k;
    }

    public double getLength() {
        return length;
    }

    public boolean isParallel(Line line) {
        if ((Double.isInfinite(this.k) || Double.isNaN(this.k)) && (Double.isInfinite(line.k) || Double.isNaN(this.k))) {
            return true;
        }
        return Math.abs(line.k - this.k) < 1e-6;
    }

    public boolean vertical(Line line) {
        if ((Double.isInfinite(this.k) && Main.cmp(line.k, 0)) || (Double.isInfinite(line.k) && Main.cmp(this.k, 0))) {
            return true;
        }
        return Math.abs(this.k * line.k + 1) < 1e-6;
    }

    public boolean inLine(Point point) {
        if (point == null) {
            return false;
        }
        if (point.equals(point1) || point.equals(point0)) {
            return false;
        }
        double distance0 = point0.distance(point1);
        double distance1 = point.distance(point0) + point.distance(point1);
        return Math.abs(distance0 - distance1) < 1e-6;
    }

    public boolean isOnLine(Point point) {
        if (Double.isInfinite(k) || Double.isNaN(k)) {
            if (Main.cmp(point.getX(), this.point0.getX()) && (point.getY() < Math.max(point0.getY(), point1.getY()) && point.getY() > Math.min(point0.getY(), point1.getY()))) {
                return true;
            }
        }
        return Main.cmp(point.getY(), point.getX() * k + c);
    }


    public Point intersection(Line line) {
        if (this.isParallel(line)) {
            return null;
        }
        if (Double.isInfinite(line.k) || Double.isNaN(line.k)) {
            return new Point((point0.getY() - c) / this.k, line.point0.getY());
        } else if (Double.isInfinite(this.k) || Double.isNaN(this.k)) {
            return new Point((point0.getY() - c) / this.k, this.point0.getY());
        } else {
            double x = -(this.c - line.c) / (this.k - line.k);
            return new Point(x, this.k * x - this.c);
        }
    }

    public double distance(Point point) {
        if (Double.isInfinite(k)) {
            return Math.abs(point.getX() - point1.getX());
        } else {
            return Math.abs(k * point.getX() - point.getY() + c) / Math.sqrt(k * k + 1);
        }
    }

    @Override
    public String toString() {
        if (Double.isInfinite(k) || Double.isNaN(k)) {
            return "Slope does not exist";
        } else {
            return String.format("%.1f", k);
        }
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }

        Line line = (Line) o;

        if ((Double.isInfinite(this.k) || Double.isNaN(this.k)) && (Double.isInfinite(line.k) || Double.isNaN(line.k))) {
            return Main.cmp(this.getPoint0().getX(), line.getPoint0().getX());
        }

        if (!Main.cmp(this.k, line.k)) {
            return false;
        }
        return Main.cmp(line.c, this.c);
    }

    @Override
    public int hashCode() {
        int result;
        long temp;
        temp = Double.doubleToLongBits(getK());
        result = (int) (temp ^ (temp >>> 32));
        temp = Double.doubleToLongBits(c);
        result = 31 * result + (int) (temp ^ (temp >>> 32));
        return result;
    }
}

class Rectangle extends Shape {
    private final Point[] points;
    private final Line[] lines;

    public Rectangle(Point point0, Point point1, Point point2, Point point3) {
        this.points = new Point[]{point0, point1, point2, point3};
        this.lines = new Line[]{new Line(point0, point1), new Line(point1, point2), new Line(point2, point3), new Line(point3, point0)};
    }

    private boolean isRectangle() {
        if (!lines[0].equals(lines[1])) {
            if (!lines[0].equals(lines[2])) {
                if (!lines[0].equals(lines[3])) {
                    if (!lines[1].equals(lines[2])) {
                        if (!lines[1].equals(lines[3])) {
                            if (!lines[2].equals(lines[3])) {
                                Point point0 = lines[0].intersection(lines[2]);
                                Point point1 = lines[3].intersection(lines[1]);


                                return !lines[1].inLine(point0) && !lines[2].inLine(point1) && !lines[3].inLine(point0) && !lines[0].inLine(point1);
                            }
                        }
                    }
                }
            }
        }
        return false;


    }

    public void checkRepeat() {
        if (!points[0].equals(points[1])) {
            if (!points[0].equals(points[2])) {
                if (!points[0].equals(points[3])) {
                    if (!points[1].equals(points[2])) {
                        if (!points[1].equals(points[3])) {
                            if (!points[2].equals(points[3])) {
                                return;
                            }
                        }
                    }
                }
            }
        }
        System.out.println("points coincide");
        System.exit(0);

    }

    private boolean isParallelogram() {
        return lines[0].isParallel(lines[2]) && lines[1].isParallel(lines[3]);
    }

    private boolean isDiamond() {
        return Main.cmp(lines[0].getLength(), lines[1].getLength()) && Main.cmp(lines[1].getLength(), lines[2].getLength()) && Main.cmp(lines[2].getLength(), lines[3].getLength());
    }

    private boolean isRec() {
        return lines[0].vertical(lines[1]) && lines[1].vertical(lines[2]) && lines[2].vertical(lines[3]) && lines[3].vertical(lines[0]);
    }


    private boolean isSquare() {
        return isDiamond() && isRec();
    }

    private boolean bump() {
        double t1 = (points[3].getX() - points[0].getX()) * (points[1].getY() - points[0].getY()) - (points[3].getY() - points[0].getY()) * (points[1].getX() - points[0].getX());
        double t2 = (points[0].getX() - points[1].getX()) * (points[2].getY() - points[1].getY()) - (points[0].getY() - points[1].getY()) * (points[2].getX() - points[1].getX());
        double t3 = (points[1].getX() - points[2].getX()) * (points[3].getY() - points[2].getY()) - (points[1].getY() - points[2].getY()) * (points[3].getX() - points[2].getX());
        double t4 = (points[2].getX() - points[3].getX()) * (points[0].getY() - points[3].getY()) - (points[2].getY() - points[3].getY()) * (points[0].getX() - points[3].getX());

        return t1 * t2 * t3 * t4 > 0;

    }

    public double perimeter() {
        return lines[0].getLength() + lines[1].getLength() + lines[2].getLength() + lines[3].getLength();
    }

    public double getArea() {
        Vector vector0 = new Vector(points[0], points[1]);
        Vector vector1 = new Vector(points[0], points[3]);

        double angle = vector0.getAngle(vector1);
        double radians = Math.toRadians(angle);

        double a = lines[0].getLength();
        double b = lines[1].getLength();
        double c = lines[2].getLength();
        double d = lines[3].getLength();

        Line line0 = new Line(points[0], points[2]);
        Line line1 = new Line(points[1], points[3]);

        double e = line0.getLength();
        double f = line1.getLength();


        double p = (a + b + c + d) / 2;

        return Math.sqrt(4 * e * e * f * f - Math.pow(a * a - b * b + c * c - d * d, 2)) / 4;

    }

    public void option1() {
        System.out.println(this.isRectangle() + " " + this.isParallelogram());
    }


    public void option2() {
        if (!isRectangle()) {
            System.out.println("not a quadrilateral");
        } else {
            System.out.println(isDiamond() + " " + isRec() + " " + isSquare());
        }
    }

    public void option3() {
        if (!this.isRectangle()) {
            System.out.println("not a quadrilateral");
        } else {
            System.out.println(bump() + " " + Main.round(this.perimeter()) + " " + Main.round(this.getArea()));
        }
    }

    public Shape toShape() {
        if (lines[0].equals(lines[1])) {
            return new Triangle(points[0], points[2], points[3]);
        } else if (lines[1].equals(lines[2])) {
            return new Triangle(points[0], points[1], points[3]);
        } else if (lines[2].equals(lines[3])) {
            return new Triangle(points[0], points[1], points[2]);
        } else if (lines[3].equals(lines[0])) {
            return new Triangle(points[1], points[2], points[3]);
        } else {
            return this;
        }
    }

    @Override
    public void option4(Line line) {
        for (Line l : lines) {
            if (line.equals(l)) {
                System.out.println("The line is coincide with one of the lines");
                return;
            }
        }

        for (Point p : points) {
            if (line.isOnLine(p)) {
                System.out.println("1");
                return;
            }
        }
        System.out.print("2 ");


    }

    @Override
    public void option5(Point point) {
        if (!this.isRectangle()) {
            System.out.println("not a quadrilateral or triangle");
            System.exit(0);
        }
        if (lines[0].inLine(point) || lines[1].inLine(point) || lines[2].inLine(point) || lines[3].inLine(point)) {
            System.out.println("on the quadrilateral");
            return;
        }
        double degree = 0;
        Vector vector0 = new Vector(point, points[0]);
        Vector vector1 = new Vector(point, points[1]);
        Vector vector2 = new Vector(point, points[2]);
        Vector vector3 = new Vector(point, points[3]);


        degree += vector0.getAngle(vector1);
        degree += vector1.getAngle(vector2);
        degree += vector2.getAngle(vector3);
        degree += vector3.getAngle(vector0);

        if (Main.cmp(degree, 360)) {
            System.out.println("in the quadrilateral");
        } else {
            System.out.println("outof the quadrilateral");
        }
    }
}

class Triangle extends Shape {
    private final Point[] points;
    private final Line[] lines;

    public Triangle(Point point0, Point point1, Point point2) {
        this.points = new Point[]{point0, point1, point2};
        this.lines = new Line[]{new Line(point0, point1), new Line(point1, point2), new Line(point2, point0)};
    }

    public boolean check() {
        if (lines[0].isParallel(lines[1]) || lines[0].isParallel(lines[2]) || lines[1].isParallel(lines[2])) {
            return false;
        }
        return !points[0].equals(points[1]) && !points[0].equals(points[2]) && !points[1].equals(points[2]);
    }

    public double getArea() {
        double p = lines[0].getLength() + lines[1].getLength() + lines[2].getLength();
        return Math.sqrt(p * (p - lines[0].getLength()) * (p - lines[1].getLength()) * (p - lines[2].getLength()));
    }

    @Override
    public void option4(Line line) {
        for (Line l : lines) {
            if (line.equals(l)) {
                System.out.println("The line is coincide with one of the lines");
                return;
            }
        }

        for (Point p : points) {
            if (line.isOnLine(p)) {
                System.out.println("1");
                return;
            }
        }

        System.out.print("2 ");

        double distance0 = line.distance(this.points[0]);
        double distance1 = line.distance(this.points[1]);
        double distance2 = line.distance(this.points[2]);

//        if(distance2 > distance1 ||)


    }

    @Override
    public void option5(Point point) {
//        if (this.check()) {
//            System.out.println("not a quadrilateral or triangle");
//            return;
//        }
        if (lines[0].inLine(point) || lines[1].inLine(point) || lines[2].inLine(point)) {
            System.out.println("on the triangle");
            return;
        }
        double degree = 0;
        Vector vector0 = new Vector(point, points[0]);
        Vector vector1 = new Vector(point, points[1]);
        Vector vector2 = new Vector(point, points[2]);


        degree += vector0.getAngle(vector1);
        degree += vector1.getAngle(vector2);
        degree += vector2.getAngle(vector0);


        if (Main.cmp(degree, 360)) {
            System.out.println("in the triangle");
        } else {
            System.out.println("outof the triangle");
        }
    }
}

class Vector {
    private double x;
    private double y;

    public Vector() {
    }

    public Vector(Point start, Point end) {
        this.x = end.getX() - start.getX();
        this.y = end.getY() - start.getY();
    }


    public double getLength() {
        return Math.sqrt(x * x + y * y);
    }

    public double getAngle(Vector vector) {
        return Math.toDegrees(Math.acos((vector.x * this.x + vector.y * this.y) / vector.getLength() / this.getLength()));
    }

}