[hs] 좌표계산기 실습 및 피드백

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-7.0.2-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.3.2-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

src/main/java/coordinate/AbstractFigure.java

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

src/main/java/coordinate/Figure.java

@@ -0,0 +1,10 @@
+package coordinate;
+
+import java.util.List;
+
+public interface Figure {
+    List<Point> getPoints();
+    int size();
+    String getName();
+    double area();
+}

src/main/java/coordinate/FigureCreator.java

@@ -0,0 +1,7 @@
+package coordinate;
+
+import java.util.List;
+
+public interface FigureCreator {
+    Figure create(List<Point> points);
+}

src/main/java/coordinate/FigureFactory.java

@@ -0,0 +1,29 @@
+package coordinate;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Function;
+
+public class FigureFactory implements FigureCreator{
+    private static final Map<Integer, Function<List<Point>, Figure>> creator;
+
+     static{
+         creator = new HashMap<>();
+         creator.put(Line.LINE_POINT_SIZE, Line::new);
+         creator.put(Triangle.TRIANGLE_POINT_SIZE, Triangle::new);
+         creator.put(Rectangle.RECTANGLE_POINT_SIZE, Rectangle::new);
+    }
+
+    @Override
+    public Figure create(List<Point> points) {
+        Function<List<Point>, Figure> figure = creator.get(points.size());
+
+        if(figure == null){
+            throw new IllegalArgumentException("유효하지 않은 도형입니다.");
+        }
+
+        return figure.apply(points);
+    }
+
+}

src/main/java/coordinate/Line.java

@@ -0,0 +1,26 @@
+package coordinate;
+
+import java.util.List;
+
+public class Line extends AbstractFigure{
+    public static final int LINE_POINT_SIZE = 2;
+
+    public Line(List<Point> points) {
+        super(points);
+    }
+
+    @Override
+    public int size() {
+        return LINE_POINT_SIZE;
+    }
+
+    @Override
+    public String getName() {
+        return "선";
+    }
+
+    @Override
+    public double area() {
+        return 0;
+    }
+}

src/main/java/coordinate/Point.java

@@ -0,0 +1,68 @@
+package coordinate;
+
+import java.util.Objects;
+
+public class Point {
+    private final int x;
+    private final int y;
+
+    public 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/Rectangle.java

@@ -0,0 +1,26 @@
+package coordinate;
+
+import java.util.List;
+
+public class Rectangle extends AbstractFigure{
+    public static final int RECTANGLE_POINT_SIZE = 4;
+
+    public Rectangle(List<Point> points) {
+        super(points);
+    }
+
+    @Override
+    public int size() {
+        return RECTANGLE_POINT_SIZE;
+    }
+
+    @Override
+    public String getName() {
+        return "사각형";
+    }
+
+    @Override
+    public double area() {
+        return 0;
+    }
+}

src/main/java/coordinate/Triangle.java

@@ -0,0 +1,26 @@
+package coordinate;
+
+import java.util.List;
+
+public class Triangle extends AbstractFigure{
+    public static final int TRIANGLE_POINT_SIZE = 3;
+
+    public Triangle(List<Point> points) {
+        super(points);
+    }
+
+    @Override
+    public int size() {
+        return TRIANGLE_POINT_SIZE;
+    }
+
+    @Override
+    public String getName() {
+        return "삼각형";
+    }
+
+    @Override
+    public double area() {
+        return 0;
+    }
+}

src/test/java/coordinate/FigureFactoryTest.java

@@ -0,0 +1,66 @@
+package coordinate;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.Arrays;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+public class FigureFactoryTest {
+
+    @Test
+    public void line() {
+        List<Point> points = Arrays.asList(
+                Point.of(1, 2),
+                Point.of(2, 3)
+        );
+
+        Figure figure = new FigureFactory().create(points);
+        assertThat(figure).isInstanceOfAny(Line.class);
+        assertThat(figure.getName()).isEqualTo("선");
+    }
+
+    @Test
+    public void triangle() {
+        List<Point> points = Arrays.asList(
+                Point.of(1, 1),
+                Point.of(4, 1),
+                Point.of(1, 4)
+        );
+
+        Figure figure = new FigureFactory().create(points);
+        assertThat(figure).isInstanceOfAny(Triangle.class);
+        assertThat(figure.getName()).isEqualTo("삼각형");
+    }
+
+    @Test
+    public void rectangle() {
+        List<Point> points = Arrays.asList(
+                Point.of(1, 1),
+                Point.of(4, 1),
+                Point.of(1, 4),
+                Point.of(4, 4)
+        );
+
+        Figure figure = new FigureFactory().create(points);
+        assertThat(figure).isInstanceOfAny(Rectangle.class);
+        assertThat(figure.getName()).isEqualTo("사각형");
+    }
+
+    @Test
+    public void illegalArgumentException(){
+        List<Point> points = Arrays.asList(
+                Point.of(1, 1),
+                Point.of(4, 1),
+                Point.of(1, 4),
+                Point.of(4, 4),
+                Point.of(4, 22)
+        );
+
+        assertThatThrownBy(() -> new FigureFactory().create(points))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessage("유효하지 않은 도형입니다.");
+    }
+}