feat: implements coordinate calculator except rectangle

src/main/java/CoordinateApplication.java

@@ -0,0 +1,16 @@
+import coordinate.Figure;
+import coordinate.FigureFactory;
+import coordinate.Points;
+import view.InputView;
+
+public class CoordinateApplication {
+    private static InputView inputView;
+    private static FigureFactory figureFactory = new FigureFactory();
+
+    public static void main(String[] args) {
+        inputView = new InputView();
+        Points points = inputView.inputPoint();
+        Figure figure = figureFactory.getInstance(points);
+        figure.output();
+    }
+}

src/main/java/coordinate/AbstractFigure.java

@@ -0,0 +1,22 @@
+package coordinate;
+
+public abstract class AbstractFigure implements Figure {
+    protected final Points points;
+
+    public AbstractFigure(Points points) {
+        if (points.size() != size()) {
+            throw new IllegalArgumentException(getName() + "의 길이는 " + size() + "이어야 합니다.");
+        }
+
+        this.points = points;
+    }
+
+//    protected Point getPoint(int index) {
+//        return points.getPoints().get(index);
+//    }
+
+    @Override
+    public Points getPoints() {
+        return points;
+    }
+}

src/main/java/coordinate/Figure.java

@@ -0,0 +1,13 @@
+package coordinate;
+
+public interface Figure {
+    Points getPoints();
+
+    int size();
+
+    String getName();
+
+    double area();
+
+    void output();
+}

src/main/java/coordinate/FigureCreator.java

@@ -0,0 +1,5 @@
+package coordinate;
+
+public interface FigureCreator {
+    Figure create(Points points);
+}

src/main/java/coordinate/FigureFactory.java

@@ -0,0 +1,24 @@
+package coordinate;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class FigureFactory {
+    public static final Map<Integer, FigureCreator> FIGURE_MAP = new HashMap<>();
+
+    static{
+        FIGURE_MAP.put(Line.LINE_POINT_SIZE, Line::new);
+        FIGURE_MAP.put(Triangle.TRIANGLE_POINT_SIZE, Triangle::new);
+        FIGURE_MAP.put(Rectangle.RECTANGLE_POINT_SIZE, Rectangle::new);
+    }
+
+    public Figure getInstance(Points points) {
+        Figure figure;
+        try{
+            figure = FIGURE_MAP.get(points.size()).create(points);
+        } catch (NullPointerException e){
+            throw new IllegalArgumentException("점의 개수는 2~4개여야 합니다.");
+        }
+        return figure;
+    }
+}

src/main/java/coordinate/Line.java

@@ -0,0 +1,29 @@
+package coordinate;
+
+public class Line extends AbstractFigure{
+    public static final int LINE_POINT_SIZE = 2;
+
+    public Line(Points points) {
+        super(points);
+    }
+
+    @Override
+    public int size() {
+        return LINE_POINT_SIZE;
+    }
+
+    @Override
+    public String getName() {
+        return "선";
+    }
+
+    @Override
+    public double area() {
+        return points.get(0).getDistance(points.get(1));
+    }
+
+    @Override
+    public void output(){
+        System.out.printf("두 점 사이의 거리는 %f", area());
+    }
+}

src/main/java/coordinate/Point.java

@@ -0,0 +1,69 @@
+package coordinate;
+
+import java.util.Objects;
+
+public class Point {
+    private final int x;
+    private final int y;
+
+    private Point(int x, int y) {
+        this.x = x;
+        if (x < 0 || x > 24) {
+            throw new IllegalArgumentException();
+        }
+
+        this.y = y;
+        if (y < 0 || y > 24) {
+            throw new IllegalArgumentException();
+        }
+    }
+
+    public double getDistance(Point other) {
+        int xDifference = other.minusX(x);
+        int yDifference = other.minusY(y);
+        return Math.sqrt(square(xDifference) + square(yDifference));
+    }
+
+    private int minusX(int number) {
+        return this.x - number;
+    }
+
+    private int minusY(int number) {
+        return this.y - number;
+    }
+
+    private static int square(int number) {
+        return number * number;
+    }
+
+    public static Point of(int x, int y) {
+        return new Point(x, y);
+    }
+
+    public static Point ofCommaSeparator(String text) {
+        String[] values = text.split(",");
+        return new Point(Integer.parseInt(values[0]), Integer.parseInt(values[1]));
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        Point point = (Point) o;
+        return x == point.x &&
+                y == point.y;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(x, y);
+    }
+
+    @Override
+    public String toString() {
+        return "Point{" +
+                "x=" + x +
+                ", y=" + y +
+                '}';
+    }
+}

src/main/java/coordinate/Points.java

@@ -0,0 +1,24 @@
+package coordinate;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Points {
+    protected static final List<Point> points = new ArrayList<>();
+
+    public void addPoint(Point point) {
+        this.points.add(point);
+    }
+
+    public Point get(int index) {
+        return points.get(index);
+    }
+
+    public static List<Point> getPoints() {
+        return points;
+    }
+
+    public int size(){
+        return this.points.size();
+    }
+}

src/main/java/coordinate/Rectangle.java

@@ -0,0 +1,29 @@
+package coordinate;
+
+public class Rectangle extends AbstractFigure {
+    public static final int RECTANGLE_POINT_SIZE = 4;
+
+    public Rectangle(Points points) {
+        super(points);
+    }
+
+    @Override
+    public int size() {
+        return RECTANGLE_POINT_SIZE;
+    }
+
+    @Override
+    public String getName() {
+        return "사각형";
+    }
+
+    @Override
+    public double area() {
+        return 0;
+    }
+
+    @Override
+    public void output() {
+        System.out.printf("사각형 넓이는 %d", area());
+    }
+}

src/main/java/coordinate/Triangle.java

@@ -0,0 +1,42 @@
+package coordinate;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Triangle extends AbstractFigure {
+    public static final int TRIANGLE_POINT_SIZE = 3;
+
+    public Triangle(Points points) {
+        super(points);
+    }
+
+    @Override
+    public int size() {
+        return TRIANGLE_POINT_SIZE;
+    }
+
+    @Override
+    public String getName() {
+        return "삼각형";
+    }
+
+    @Override
+    public double area() {
+        List<Double> distances = new ArrayList<>();
+        distances.add(points.get(0).getDistance(points.get(1)));
+        distances.add(points.get(1).getDistance(points.get(2)));
+        distances.add(points.get(2).getDistance(points.get(0)));
+        Double s = distances.stream().mapToDouble(i->i).sum() /2;
+        Double result = s;
+        for(Double d: distances){
+            result *= (s-d);
+        }
+
+        return Math.sqrt(result);
+    }
+
+    @Override
+    public void output() {
+        System.out.printf("삼각형 넓이는 %f", area());
+    }
+}

src/main/java/view/InputView.java

@@ -0,0 +1,34 @@
+package view;
+
+import coordinate.Point;
+import coordinate.Points;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Scanner;
+import java.util.stream.Collectors;
+
+public class InputView {
+    Scanner scanner = new Scanner(System.in);
+
+    public Points inputPoint(){
+        System.out.println("좌표를 입력하세요.");
+        String s = scanner.next();
+
+        Points points = new Points();
+        String[] strings = s.split("-");
+        for(String str: strings){
+            List<Integer> numbers = new ArrayList<>();
+            List<String> nums;
+            nums = Arrays.stream(str.split("\\(|,|\\)")).filter(t -> !t.isEmpty()).collect(Collectors.toList());
+            for(String n: nums){
+                numbers.add(Integer.valueOf(n));
+            }
+
+            Point point = Point.of(numbers.get(0), numbers.get(1));
+            points.addPoint(point);
+        }
+        return points;
+    }
+}

src/main/java/view/OutputView.java

@@ -0,0 +1,4 @@
+package view;
+
+public class OutputView {
+}