javajigi · Oct 25, 2018 · Oct 25, 2018 · Oct 25, 2018 · Oct 25, 2018
diff --git a/src/main/java/MainCoordinate.java b/src/main/java/MainCoordinate.java
@@ -1,3 +1,4 @@
+import additionalException.DuplicatePointException;
 import domain.*;
 import util.Parser;
 
@@ -14,27 +15,26 @@ public static void main(String[] args) {
     private static void start() {
         try {
             List<Point> points = PointsFactory.makePoints(Parser.makePosition(getCoordinateValue()));
-            printCoordinate(points);
             decideFigure(points);
-
-        } catch (IllegalArgumentException e) {
-            System.out.println("좌표값을 잘못 입력했습니다. 다시 입력하세요.");
+            printCoordinate(points);
+        } catch (IllegalArgumentException | DuplicatePointException e) {
+            System.out.println(e.getMessage());
             start();
         }
     }
 
     private static void decideFigure(List<Point> points) {
         if (points.size() == 4) {
             Rectangle rectangle = new Rectangle(points);
-            printRectangleArea(rectangle.calculateArea());
+            printRectangleArea(rectangle.area());
         }
         if (points.size() == 3) {
             Triangle triangle = new Triangle(points);
-            printTriangleArea(triangle.calculateArea());
+            printTriangleArea(triangle.area());
         }
         if (points.size() == 2) {
             Line line = new Line(points);
-            printLineLength(line.calculateLength());
+            printLineLength(line.area());
         }
     }
 }
diff --git a/src/main/java/additionalException/DuplicatePointException.java b/src/main/java/additionalException/DuplicatePointException.java
@@ -0,0 +1,8 @@
+package additionalException;
+
+public class DuplicatePointException extends RuntimeException {
+
+    public DuplicatePointException(String s) {
+        super(s);
+    }
+}
diff --git a/src/main/java/domain/Figure.java b/src/main/java/domain/Figure.java
@@ -0,0 +1,38 @@
+package domain;
+
+import additionalException.DuplicatePointException;
+
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+public abstract class Figure {
+    private List<Point> points;
+
+    Figure(List<Point> points) {
+        checkDuplicationPoint(points);
+        this.points = points;
+    }
+
+    protected Point getPoint(int index) {
+        return points.get(index);
+    }
+
+    protected int getPointsSize() {
+        return points.size();
+    }
+
+    private void checkDuplicationPoint(List<Point> points) {
+        Set<Point> copyOfPoints = new HashSet<>(points);
+        if (points.size() != copyOfPoints.size())
+            throw new DuplicatePointException("위치가 같은 점(point)이 존재합니다. 모든 점들의 위치는 달라야 합니다.");
+    }
+
+    protected void checkSize(int size){
+        if(points.size()!=size){
+            throw new IllegalArgumentException();
+        }
+    }
+
+    protected abstract double area();
+}
diff --git a/src/main/java/domain/Line.java b/src/main/java/domain/Line.java
@@ -2,23 +2,17 @@
 
 import java.util.List;
 
-public class Line {
+public class Line extends Figure{
     private static final int FIRST_POINT = 0;
     private static final int SECOND_POINT = 1;
-    private List<Point> points;
+    private static final int TWO = 2;
 
     public Line(List<Point> points) {
-        checkSize(points);
-        this.points = points;
+        super(points);
+        checkSize(TWO);
     }
 
-    private void checkSize(List<Point> points) {
-        if (points.size() != 2) {
-            throw new IllegalArgumentException();
-        }
-    }
-
-    public double calculateLength() {
-        return points.get(FIRST_POINT).calculateLength(points.get(SECOND_POINT));
+    public double area() {
+        return getPoint(FIRST_POINT).calculateLength(getPoint(SECOND_POINT));
     }
 }
diff --git a/src/main/java/domain/Point.java b/src/main/java/domain/Point.java
@@ -1,5 +1,7 @@
 package domain;
 
+import java.util.Objects;
+
 public class Point {
     private static final int LINE_SIZE = 51;
     private static final int MAX_POINT_VALUE = 24;
@@ -11,9 +13,9 @@ public class Point {
     private int yPos;
 
     public Point(int xPos, int yPos) {
-        if (xPos > MAX_POINT_VALUE || xPos < 0) throw new IllegalArgumentException();
+        if (xPos > MAX_POINT_VALUE || xPos < 0) throw new IllegalArgumentException("좌표값을 잘못 입력했습니다. 다시 입력하세요.");
         this.xPos = xPos;
-        if (yPos > MAX_POINT_VALUE || yPos < 0) throw new IllegalArgumentException();
+        if (yPos > MAX_POINT_VALUE || yPos < 0) throw new IllegalArgumentException("좌표값을 잘못 입력했습니다. 다시 입력하세요.");
         this.yPos = yPos;
     }
 
@@ -34,4 +36,18 @@ public int findPointPosition() {
     double calculateLength(Point p) {
         return Math.sqrt(Math.pow(this.subtractXPoint(p), 2) + Math.pow(this.subtractYPoint(p), 2));
     }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        Point point = (Point) o;
+        return xPos == point.xPos &&
+                yPos == point.yPos;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(xPos, yPos);
+    }
 }
diff --git a/src/main/java/domain/PointsFactory.java b/src/main/java/domain/PointsFactory.java
@@ -8,10 +8,11 @@ public class PointsFactory {
     private static final int Y_POSITION = 1;
 
     public static List<Point> makePoints(List<Integer[]> positions) {
-        List<Point> pointList = new ArrayList<>();
+        List<Point> points = new ArrayList<>();
         for (Integer[] position : positions) {
-            pointList.add(new Point(position[X_POSITION], position[Y_POSITION]));
+            Point point = new Point(position[X_POSITION], position[Y_POSITION]);
+            points.add(point);
         }
-        return pointList;
+        return points;
     }
 }
diff --git a/src/main/java/domain/Rectangle.java b/src/main/java/domain/Rectangle.java
@@ -4,45 +4,33 @@
 import java.util.Collections;
 import java.util.List;
 
-public class Rectangle {
+public class Rectangle extends Figure {
     private static final int ZERO = 0;
     private static final int ONE = 1;
     private static final int FOUR = 4;
 
-    private List<Point> points;
-
     public Rectangle(List<Point> points) {
+        super(points);
+        checkSize(FOUR);
         check(points);
-        this.points = points;
     }
 
     private void check(List<Point> points) {
-        checkSize(points);
         int check = 0;
         for (Point point : points) {
-            check += cntCoordinateValue(0, 0, point, points);
+            check += cntCoordinateValue(point, points);
         }
         checkRectangle(check);
     }
 
-    private void checkSize(List<Point> points) {
-        if (points.size() != 4) {
-            throw new IllegalArgumentException();
-        }
-    }
-
-    private int cntCoordinateValue(int xCnt, int yCnt, Point point, List<Point> points) {
+    private int cntCoordinateValue(Point point, List<Point> points) {
+        int xCnt = 0;
+        int yCnt = 0;
         for (Point other : points) {
-            if (point.subtractXPoint(other) == ZERO) {
-                xCnt++;
-            }
-            if (point.subtractYPoint(other) == ZERO) {
-                yCnt++;
-            }
-        }
-        if (xCnt == 2 && yCnt == 2) {
-            return ONE;
+            if (point.subtractXPoint(other) == ZERO) xCnt++;
+            if (point.subtractYPoint(other) == ZERO) yCnt++;
         }
+        if (xCnt == 2 && yCnt == 2) return ONE;
         return ZERO;
     }
 
@@ -53,12 +41,13 @@ private void checkRectangle(int check) {
         throw new IllegalArgumentException("사각형이 아닙니다");
     }
 
-    public int calculateArea() {
+    @Override
+    public double area() {
         List<Double> length = new ArrayList<>();
-        for (int i = 0; i < points.size() - 1; i++) {
-            length.add(points.get(i).calculateLength(points.get(i + 1)));
+        for (int i = 0; i < getPointsSize() - 1; i++) {
+            length.add(getPoint(i).calculateLength(getPoint(i + 1)));
         }
         Collections.sort(length);
-        return (int) (length.get(ZERO) * length.get(ONE));
+        return (length.get(ZERO) * length.get(ONE));
     }
 }
diff --git a/src/main/java/domain/Triangle.java b/src/main/java/domain/Triangle.java
@@ -3,46 +3,40 @@
 import java.util.ArrayList;
 import java.util.List;
 
-public class Triangle {
+public class Triangle extends Figure {
     private static final int ZERO = 0;
     private static final int ONE = 1;
     private static final int TWO = 2;
-
-    private List<Point> points;
+    private static final int THREE = 3;
 
     public Triangle(List<Point> points) {
-        checkSize(points);
-        this.points = points;
-    }
-
-    private void checkSize(List<Point> points) {
-        if (points.size() != 3) {
-            throw new IllegalArgumentException();
-        }
+        super(points);
+        checkSize(THREE);
     }
 
     //삼각형 길이 구하기
     private List<Double> calculateTriangleLength() {
         List<Double> lengths = new ArrayList<>();
-        lengths.add(points.get(ZERO).calculateLength(points.get(ONE)));
-        lengths.add(points.get(ONE).calculateLength(points.get(TWO)));
-        lengths.add(points.get(ZERO).calculateLength(points.get(TWO)));
+        lengths.add(getPoint(ZERO).calculateLength(getPoint(ONE)));
+        lengths.add(getPoint(ONE).calculateLength(getPoint(TWO)));
+        lengths.add(getPoint(ZERO).calculateLength(getPoint(TWO)));
         return lengths;
     }
 
     //헤론 공식
     private double findS(List<Double> lengths) {
         double sum = 0;
-        for (int i = 0; i < points.size() - 1; i++) {
-            lengths.add(points.get(i).calculateLength(points.get(i + 1)));
+        for (int i = 0; i < getPointsSize() - 1; i++) {
+            lengths.add(getPoint(i).calculateLength(getPoint(i + 1)));
             sum += lengths.get(i);
         }
-        lengths.add(points.get(ZERO).calculateLength(points.get(TWO)));
+        lengths.add(getPoint(ZERO).calculateLength(getPoint(TWO)));
         sum += lengths.get(TWO);
         return (sum / 2);
     }
 
-    public double calculateArea() {
+    @Override
+    public double area() {
         List<Double> lengths = calculateTriangleLength();
         double s = findS(lengths);
         return Math.sqrt(s * (s - lengths.get(ZERO)) * (s - lengths.get(ONE)) * (s - lengths.get(TWO)));

diff --git a/src/main/java/util/Parser.java b/src/main/java/util/Parser.java
@@ -29,7 +29,7 @@ private static Integer[] stringToInteger(String[] str) {
         return pos;
     }
 
-    private static List<Integer[]> makePostionList(String[] temp) {
+    private static List<Integer[]> makePositionList(String[] temp) {
         List<Integer[]> pos = new ArrayList<>();
         for (String t : temp) {
             pos.add(stringToInteger(splitComma(t)));        //a,b,c,d
@@ -40,6 +40,6 @@ private static List<Integer[]> makePostionList(String[] temp) {
     public static List<Integer[]> makePosition(String input) {
         String[] str = splitHyphen(input);           //"(a,b)","(c,d)"
         String[] temp = removeBracket(str);     //"a,b","c,d"
-        return makePostionList(temp);
+        return makePositionList(temp);
     }
 }
diff --git a/src/main/java/view/ResultView.java b/src/main/java/view/ResultView.java
@@ -22,8 +22,8 @@ public static void printLineLength(double len) {
         System.out.println("두 점 사이 거리는 " + String.format("%.6f", len));
     }
 
-    public static void printRectangleArea(int area) {
-        System.out.println("사각형의 넓이는 " + area);
+    public static void printRectangleArea(double area) {
+        System.out.println("사각형의 넓이는 " + String.format("%.0f",area));
     }
 
     public static void printTriangleArea(double area) {

diff --git a/src/test/java/domain/LineTest.java b/src/test/java/domain/LineTest.java
@@ -16,6 +16,6 @@ public void calcLengthTest() {
         pl.add(p1);
         pl.add(p2);
         Line line = new Line(pl);
-        assertThat( line.calculateLength()).isEqualTo(5.0000);
+        assertThat( line.area()).isEqualTo(5.0000);
     }
 }
diff --git a/src/test/java/domain/RectangleTest.java b/src/test/java/domain/RectangleTest.java
@@ -21,7 +21,7 @@ public void chooseThreePointTest(){
         points.add(p3);
         points.add(p4);
         Rectangle rectangle = new Rectangle(points);
-        assertThat(rectangle.calculateArea()).isEqualTo(96) ;
+        assertThat(rectangle.area()).isEqualTo(96) ;
     }
 
     @Test