Sdrs6921

build.gradle

@@ -3,7 +3,7 @@ apply plugin: 'eclipse'
 
 group = 'camp.nextstep'
 version = '1.0.0'
-sourceCompatibility = '1.8'
+sourceCompatibility = '11'
 
 repositories {
 	mavenCentral()

src/main/java/coordinate/CoordinateMain.java

@@ -0,0 +1,20 @@
+package coordinate;
+
+import coordinate.controller.CoordinateController;
+import coordinate.view.InputConsoleView;
+import coordinate.view.InputView;
+import coordinate.view.OutputConsoleView;
+import coordinate.view.OutputView;
+
+import java.util.Scanner;
+
+public class CoordinateMain {
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        InputView inputView = new InputConsoleView(scanner);
+        OutputView outputView = new OutputConsoleView();
+        CoordinateController coordinateController = new CoordinateController(inputView, outputView);
+        coordinateController.run();
+        scanner.close();
+    }
+}

src/main/java/coordinate/controller/CoordinateController.java

@@ -0,0 +1,49 @@
+package coordinate.controller;
+
+import coordinate.domain.Figure;
+import coordinate.domain.FigureFactory;
+import coordinate.domain.Line;
+import coordinate.domain.StraightLine;
+import coordinate.domain.vo.Point;
+import coordinate.view.InputView;
+import coordinate.view.OutputView;
+
+import java.util.List;
+
+public class CoordinateController {
+
+    private static final int NUMBER_OF_LINE = 2;
+
+    private final InputView inputView;
+    private final OutputView outputView;
+
+    public CoordinateController(final InputView inputView, final OutputView outputView) {
+        this.inputView = inputView;
+        this.outputView = outputView;
+    }
+
+    public void run() {
+        List<Point> points = inputView.input();
+
+        if (isLineNumberOf(points)) {
+            printLine(points);
+            return;
+        }
+
+        printFigure(points);
+    }
+
+    private boolean isLineNumberOf(final List<Point> points) {
+        return points.size() == NUMBER_OF_LINE;
+    }
+
+    private void printLine(final List<Point> points) {
+        Line line = new StraightLine(points);
+        outputView.printLine(line);
+    }
+
+    private void printFigure(final List<Point> points) {
+        Figure figure = FigureFactory.create(points);
+        outputView.printFigure(figure);
+    }
+}

src/main/java/coordinate/domain/Figure.java

@@ -0,0 +1,7 @@
+package coordinate.domain;
+
+public interface Figure {
+    double area();
+
+    String figureType();
+}

src/main/java/coordinate/domain/FigureFactory.java

@@ -0,0 +1,38 @@
+package coordinate.domain;
+
+import coordinate.domain.vo.Point;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Function;
+
+public class FigureFactory {
+
+    private static final String INVALID_NUMBER_OF_POINTS_MESSAGE = "유효하지 않은 점의 개수입니다";
+    private static final int NUMBER_OF_TRIANGLE_POINTS = 3;
+    private static final int NUMBER_OF_RECTANGLE_POINTS = 4;
+
+    private static final Map<Integer, Function<List<Point>, Figure>> factory = new HashMap<>();
+
+    static {
+        factory.put(NUMBER_OF_TRIANGLE_POINTS, Triangle::new);
+        factory.put(NUMBER_OF_RECTANGLE_POINTS, Rectangle::new);
+    }
+
+    private FigureFactory() {
+
+    }
+
+    public static Figure create(final List<Point> points) {
+        int numberOfPoints = points.size();
+        validateNumberOfPoints(numberOfPoints);
+        return factory.get(numberOfPoints).apply(points);
+    }
+
+    private static void validateNumberOfPoints(final int numberOfPoints) {
+        if (numberOfPoints < NUMBER_OF_TRIANGLE_POINTS || numberOfPoints > NUMBER_OF_RECTANGLE_POINTS) {
+            throw new IllegalArgumentException(INVALID_NUMBER_OF_POINTS_MESSAGE);
+        }
+    }
+}

src/main/java/coordinate/domain/Line.java

@@ -0,0 +1,6 @@
+package coordinate.domain;
+
+@FunctionalInterface
+public interface Line {
+    double length();
+}

src/main/java/coordinate/domain/Rectangle.java

@@ -0,0 +1,112 @@
+package coordinate.domain;
+
+import coordinate.domain.vo.Coordinate;
+import coordinate.domain.vo.Point;
+
+import java.util.HashSet;
+import java.util.List;
+import java.util.Objects;
+import java.util.Set;
+import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+import static java.util.Arrays.asList;
+
+public class Rectangle implements Figure {
+
+    private static final int NUMBER_OF_RECTANGLE_POINTS = 4;
+    private static final int NUMBER_OF_DUPLICATED_COORDINATE = 2;
+
+    private static final String INVALID_NUMBER_OF_RECTANGLE_POINTS_MESSAGE = "사각형의 점은 4개여야 합니다";
+    private static final String INVALID_RECTANGLE_MESSAGE = "직사각형이 아닙니다";
+    private static final String DUPLICATE_POINTS_EXCEPTION_MESSAGE = "점 사이에 중복이 존재합니다";
+
+    private final List<Point> points;
+
+    public Rectangle(final List<Point> points) {
+        validateNumberOf(points);
+        validateDuplicateOf(points);
+        validateIsRectangle(points);
+        this.points = points;
+    }
+
+    private void validateNumberOf(final List<Point> points) {
+        if (points.size() != NUMBER_OF_RECTANGLE_POINTS) {
+            throw new IllegalArgumentException(INVALID_NUMBER_OF_RECTANGLE_POINTS_MESSAGE);
+        }
+    }
+
+    private void validateDuplicateOf(final List<Point> points) {
+        Set<Point> distinctPoints = new HashSet<>(points);
+
+        if (distinctPoints.size() < points.size()) {
+            throw new IllegalArgumentException(DUPLICATE_POINTS_EXCEPTION_MESSAGE);
+        }
+    }
+
+    private void validateIsRectangle(final List<Point> points) {
+        Set<Coordinate> duplicatedRemovedXCoordinate = removeDuplicateCoordinate(points, Point::x);
+        Set<Coordinate> duplicatedRemovedYCoordinate = removeDuplicateCoordinate(points, Point::y);
+
+        if (hasTwo(duplicatedRemovedXCoordinate) && hasTwo(duplicatedRemovedYCoordinate)) {
+            throw new IllegalArgumentException(INVALID_RECTANGLE_MESSAGE);
+        }
+    }
+
+    private Set<Coordinate> removeDuplicateCoordinate(final List<Point> points,
+                                                      final Function<Point, Coordinate> extractedFunction) {
+        return points.stream()
+                .map(extractedFunction)
+                .collect(Collectors.toSet());
+    }
+
+    private boolean hasTwo(final Set<Coordinate> duplicatedRemovedCoordinate) {
+        return duplicatedRemovedCoordinate.size() != NUMBER_OF_DUPLICATED_COORDINATE;
+    }
+
+    private List<Point> points() {
+        return points;
+    }
+
+    @Override
+    public String figureType() {
+        return "사각형";
+    }
+
+    @Override
+    public double area() {
+        Point point = points.get(0);
+        Point sameXCoordinatePoint = getSameCoordinatePoint(point::hasSameXCoordinate);
+        Point sameYCoordinatePoint = getSameCoordinatePoint(point::hasSameYCoordinate);
+
+        Line width = new StraightLine(asList(point, sameXCoordinatePoint));
+        Line height = new StraightLine(asList(point, sameYCoordinatePoint));
+
+        return width.length() * height.length();
+    }
+
+    private Point getSameCoordinatePoint(final Predicate<Point> hasSameCoordinatePredicate) {
+        int startIndex = 1;
+
+        return IntStream.range(startIndex, points.size())
+                .mapToObj(points::get)
+                .filter(hasSameCoordinatePredicate)
+                .findAny()
+                .orElseThrow(() -> new IllegalStateException(INVALID_RECTANGLE_MESSAGE));
+    }
+
+    @Override
+    public boolean equals(final Object other) {
+        if (this == other) return true;
+        if (!(other instanceof Rectangle)) return false;
+        final Rectangle rectangle = (Rectangle) other;
+        return points().equals(rectangle.points());
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(points);
+    }
+}

src/main/java/coordinate/domain/StraightLine.java

@@ -0,0 +1,60 @@
+package coordinate.domain;
+
+import coordinate.domain.vo.Point;
+
+import java.util.HashSet;
+import java.util.List;
+import java.util.Objects;
+import java.util.Set;
+
+public class StraightLine implements Line {
+
+    private static final int NUMBER_OF_LINE_POINTS = 2;
+
+    private static final String INVALID_NUMBER_OF_STRAIGHT_LINE_POINTS_EXCEPTION_MESSAGE = "선의 점의 개수는 2개여야 합니다";
+    private static final String DUPLICATE_LINE_POINTS_EXCEPTION_MESSAGE = "점 사이에 중복이 존재합니다";
+
+    private final List<Point> points;
+
+    public StraightLine(List<Point> points) {
+        validateNumberOf(points);
+        validateDuplicateOf(points);
+        this.points = points;
+    }
+
+    private void validateNumberOf(final List<Point> points) {
+        if (points.size() != NUMBER_OF_LINE_POINTS) {
+            throw new IllegalArgumentException(INVALID_NUMBER_OF_STRAIGHT_LINE_POINTS_EXCEPTION_MESSAGE);
+        }
+    }
+
+    private void validateDuplicateOf(final List<Point> points) {
+        Set<Point> distinctPoints = new HashSet<>(points);
+
+        if (distinctPoints.size() < points.size()) {
+            throw new IllegalArgumentException(DUPLICATE_LINE_POINTS_EXCEPTION_MESSAGE);
+        }
+    }
+
+    private List<Point> points() {
+        return points;
+    }
+
+    @Override
+    public double length() {
+        return points.get(0).distance(points.get(1));
+    }
+
+    @Override
+    public boolean equals(final Object other) {
+        if (this == other) return true;
+        if (!(other instanceof StraightLine)) return false;
+        final StraightLine that = (StraightLine) other;
+        return points().equals(that.points());
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(points);
+    }
+}