[jhlee] Mission2 - 좌표 계산기 삼각형 면적

src/main/java/coordinate/MainApplication.java

@@ -0,0 +1,20 @@
+package coordinate;
+
+import coordinate.figure.Figure;
+import coordinate.figure.FigureFactory;
+import coordinate.figure.FigureSize;
+import coordinate.graph.Graph;
+import coordinate.io.ConsoleInputHandler;
+import coordinate.io.ConsoleOutputHandler;
+
+public class MainApplication {
+    private static final ConsoleInputHandler inputHandler = new ConsoleInputHandler();
+    private static final ConsoleOutputHandler outputHandler = new ConsoleOutputHandler();
+
+    public static void main(String[] args) {
+        FigureSize figureSize = inputHandler.getFigureSize();
+        Figure figure = FigureFactory.create(figureSize);
+        Graph graph = Graph.from(figure);
+        outputHandler.printGraph(graph);
+    }
+}

src/main/java/coordinate/exception/CoordinateException.java

@@ -0,0 +1,8 @@
+package coordinate.exception;
+
+public class CoordinateException extends RuntimeException {
+
+    public CoordinateException(String message) {
+        super(message);
+    }
+}

src/main/java/coordinate/figure/Figure.java

@@ -0,0 +1,8 @@
+package coordinate.figure;
+
+public interface Figure {
+
+    double calculate();
+
+    boolean isMark(int x, int y);
+}

src/main/java/coordinate/figure/FigureFactory.java

@@ -0,0 +1,8 @@
+package coordinate.figure;
+
+public class FigureFactory {
+
+    public static Figure create(FigureSize figureSize) {
+        return FigureType.create(figureSize);
+    }
+}

src/main/java/coordinate/figure/FigureSize.java

@@ -0,0 +1,33 @@
+package coordinate.figure;
+
+import coordinate.point.Coordinate;
+import coordinate.point.Points;
+import coordinate.utils.StringUtils;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class FigureSize {
+
+    private final List<Coordinate> figureSizes;
+
+    private FigureSize(List<Coordinate> figureSizes) {
+        this.figureSizes = figureSizes;
+    }
+
+    public static FigureSize from(String userInputFigureSize) {
+        List<String> splitedByHyphen = StringUtils.splitByHyphen(userInputFigureSize);
+
+        List<Coordinate> figureSizes = splitedByHyphen.stream()
+                .map(Coordinate::from)
+                .collect(Collectors.toList());
+
+        return new FigureSize(figureSizes);
+    }
+
+    public Points toPoints() {
+        return Points.from(figureSizes.stream()
+                .map(Coordinate::toPoint)
+                .collect(Collectors.toList()));
+    }
+
+}

src/main/java/coordinate/figure/FigureType.java

@@ -0,0 +1,45 @@
+package coordinate.figure;
+
+import coordinate.exception.CoordinateException;
+import coordinate.messages.ErrorMessage;
+import coordinate.point.Points;
+import java.util.Arrays;
+
+public enum FigureType {
+    LINE(2) {
+        @Override
+        public Figure createFigure(Points points) {
+            return Line.from(points);
+        }
+    },
+    RECTANGLE(4) {
+        @Override
+        public Figure createFigure(Points points) {
+            return Rectangle.from(points);
+        }
+    },
+    TRIANGLE(3) {
+        @Override
+        public Figure createFigure(Points points) {
+            return Triangle.from(points);
+        }
+    };
+
+    private final int pointsSize;
+
+    FigureType(int pointsSize) {
+        this.pointsSize = pointsSize;
+    }
+
+    public abstract Figure createFigure(Points points);
+
+    public static Figure create(FigureSize figureSize) {
+        Points points = figureSize.toPoints();
+
+        return Arrays.stream(values())
+                .filter(type -> type.pointsSize == points.size())
+                .findFirst()
+                .orElseThrow(() -> new CoordinateException(ErrorMessage.invalidFigureSize))
+                .createFigure(points);
+    }
+}

src/main/java/coordinate/figure/Line.java

@@ -0,0 +1,59 @@
+package coordinate.figure;
+
+import coordinate.point.Point;
+import coordinate.point.Points;
+import java.util.List;
+
+public class Line implements Figure {
+
+    private final Points points;
+
+    private Line(Points points) {
+        this.points = points;
+    }
+
+    public static Line from(Points points) {
+        return new Line(points);
+    }
+
+    @Override
+    public String toString() {
+        return String.format("두 점 사이의 거리는: " + calculate());
+    }
+
+    @Override
+    public boolean isMark(int x, int y) {
+        return points.isMarkedAt(x, y);
+    }
+
+    /**
+     * 제곱근((A.x - B.x)^제곱 + (A.y - B.y)^제곱)
+     */
+    @Override
+    public double calculate() {
+        List<Point> points = this.points.getPoints();
+
+        Point firstPoint = getFirstPoint(points);
+        Point secondPoint = getSecondPoint(points);
+
+        return calculateDistanceBetweenPoints(firstPoint, secondPoint);
+    }
+
+    private Point getFirstPoint(List<Point> points) {
+        return points.get(0);
+    }
+
+    private Point getSecondPoint(List<Point> points) {
+        return points.get(1);
+    }
+
+    private double calculateDistanceBetweenPoints(Point point1, Point point2) {
+        double subX = square(point1.subtractionByX(point2));
+        double subY = square(point1.subtractionByY(point2));
+        return Math.sqrt(subX + subY);
+    }
+
+    private double square(int value) {
+        return Math.pow(value, 2);
+    }
+}

src/main/java/coordinate/figure/Rectangle.java

@@ -0,0 +1,58 @@
+package coordinate.figure;
+
+import coordinate.point.Point;
+import coordinate.point.Points;
+import java.util.List;
+
+public class Rectangle implements Figure {
+
+    private final Points points;
+
+    private Rectangle(Points points) {
+        this.points = points;
+    }
+
+    public static Rectangle from(Points points) {
+        return new Rectangle(points);
+    }
+
+    @Override
+    public boolean isMark(int x, int y) {
+        return points.isMarkedAt(x, y);
+    }
+
+    @Override
+    public String toString() {
+        return "사각형의 넓이는 " + (int) calculate();
+    }
+
+    /**
+     * width * height
+     */
+    @Override
+    public double calculate() {
+        List<Point> points = this.points.getPoints();
+
+        Point leftBottomPoint = getLeftBottomPoint(points);
+        Point rightTopPoint = getRightTopPoint(points);
+
+        return getWidth(leftBottomPoint, rightTopPoint) * getHeight(leftBottomPoint, rightTopPoint);
+    }
+
+    private Point getLeftBottomPoint(List<Point> points) {
+        return points.get(0);
+    }
+
+    private static Point getRightTopPoint(List<Point> points) {
+        return points.get(2);
+    }
+
+    private double getWidth(Point point1, Point point2) {
+        return Math.abs(point1.subtractionByX(point2));
+    }
+
+    private double getHeight(Point point1, Point point2) {
+        return Math.abs(point1.subtractionByY(point2));
+    }
+
+}

src/main/java/coordinate/figure/Triangle.java

@@ -0,0 +1,78 @@
+package coordinate.figure;
+
+import coordinate.point.Point;
+import coordinate.point.Points;
+import java.util.ArrayList;
+import java.util.List;
+
+public class Triangle implements Figure{
+
+    private final Points points;
+
+    private Triangle(Points points) {
+        this.points = points;
+    }
+
+    public static Triangle from(Points points) {
+        return new Triangle(points);
+    }
+
+    @Override
+    public boolean isMark(int x, int y) {
+        return points.isMarkedAt(x, y);
+    }
+
+    @Override
+    public String toString() {
+        return "삼각형의 넓이는 " + (double) Math.round(calculate());
+    }
+
+    @Override
+    public double calculate() {
+        List<Double> distances = getDistances();
+        double half = getHalf(distances);
+        return getTriangleWidthByDistances(distances, half);
+    }
+
+    private List<Double> getDistances() {
+        List<Point> pointsArray = points.getPoints();
+        List<Double> distances = new ArrayList<>();
+
+        for (int i = 0; i < points.size(); i++) {
+            int nextIndex = getPointNextIndex(i);
+            distances.add(getPointsBetweenDistance(pointsArray.get(i), pointsArray.get(nextIndex)));
+        }
+
+        return distances;
+    }
+
+    private int getPointNextIndex(int index) {
+        int pointSize = points.size();
+
+        if (index == pointSize-1) {
+            return 0;
+        }
+
+        return index + 1;
+    }
+
+    private double getPointsBetweenDistance(Point point1, Point point2) {
+        Line line = Line.from(Points.from(List.of(point1, point2)));
+        return line.calculate();
+    }
+
+    private double getHalf(List<Double> distances) {
+        return distances.stream().mapToDouble(Double::doubleValue).sum() / 2;
+    }
+
+    private double getTriangleWidthByDistances(List<Double> distances, double half) {
+        double width = 1;
+        for (double distance : distances) {
+            width *= (half - distance);
+        }
+        width *= half;
+
+        return Math.sqrt(width);
+    }
+
+}