Polymorphism - 팩토리 클래스 완성 및 V1 클래스 삭제

src/main/java/Main.java

@@ -0,0 +1,6 @@
+import figure.FigureFactory;
+
+public class Main {
+    public static void main(String[] args) {
+    }
+}

src/main/java/app/FigureGame.java

@@ -0,0 +1,18 @@
+package app;
+
+import view.InputView;
+import view.OutputView;
+
+import java.io.IOException;
+
+public class FigureGame {
+    private FigureGame() {
+        throw new IllegalArgumentException();
+    }
+
+    public static void game() throws IOException {
+        OutputView.printGetInput();
+        String[] userInputDots = InputView.getInput();
+        OutputView.printOutput(userInputDots);
+    }
+}

src/main/java/app/Main.java

@@ -0,0 +1,9 @@
+package app;
+
+import java.io.IOException;
+
+public class Main {
+    public static void main(String[] args) throws IOException {
+        FigureGame.game();
+    }
+}

src/main/java/figure/AbstractFigure.java

@@ -0,0 +1,21 @@
+package figure;
+
+import java.util.List;
+
+public abstract class AbstractFigure implements Figure{
+    private final List<Dot> dotList;
+
+    protected AbstractFigure(List<Dot> dotList) {
+        if (dotList.size() != this.size()){
+            throw new IllegalArgumentException();
+        }
+        this.dotList = dotList;
+    }
+    public Dot getDot(int index){
+        return this.dotList.get(index);
+    }
+    @Override
+    public List<Dot> getDots(){
+        return this.dotList;
+    }
+}

src/main/java/figure/Dot.java

@@ -0,0 +1,56 @@
+package figure;
+
+import java.util.Objects;
+
+public class Dot {
+    private final int x;
+    private final int y;
+    private static final String INVALID_INPUT_FORMAT = "Invalid input format";
+    private static final String REGEX_FOR_STRING_INPUT = "[()]";
+    private static final int MAX_LOCATION_FOR_DOT = 24;
+    private Dot(int x, int y) {
+        validateLocations(x, y);
+        this.x = x;
+        this.y = y;
+    }
+    public static Dot ofTest(int x, int y){
+        return new Dot(x,y);
+    }
+    public static Dot of(String input){
+        String[] parts = input.replaceAll(REGEX_FOR_STRING_INPUT, "").split(",");
+        if (parts.length != 2) {
+            throw new IllegalArgumentException(INVALID_INPUT_FORMAT);
+        }
+        int x = Integer.parseInt(parts[0].trim());
+        int y = Integer.parseInt(parts[1].trim());
+        return new Dot(x, y);
+    }
+
+    private void validateLocations(int x, int y) {
+        if (x > MAX_LOCATION_FOR_DOT || y > MAX_LOCATION_FOR_DOT) throw new IllegalArgumentException();
+    }
+
+    public double getDistanceBetween(Dot secondDot) {
+        return Math.sqrt(Math.pow((secondDot.x - this.x), 2) + Math.pow((secondDot.y - this.y), 2));
+    }
+    public boolean isXParallel(Dot dot) {
+        return this.y == dot.y;
+    }
+
+    public boolean isYParallel(Dot dot) {
+        return this.x == dot.x;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        Dot dot = (Dot) o;
+        return x == dot.x && y == dot.y;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(x, y);
+    }
+}

src/main/java/figure/FactoryFunction.java

@@ -0,0 +1,8 @@
+package figure;
+
+import java.util.List;
+
+@FunctionalInterface
+public interface FactoryFunction {
+    Figure create(List<Dot> dotList);
+}

src/main/java/figure/Figure.java

@@ -0,0 +1,10 @@
+package figure;
+
+import java.util.List;
+
+public interface Figure {
+    String getName();
+    int size();
+    double getArea();
+    List<Dot> getDots();
+}

src/main/java/figure/FigureEnum.java

@@ -0,0 +1,22 @@
+package figure;
+
+public enum FigureEnum {
+    LINE("Line", 2),
+    TRIANGLE("Triangle", 3),
+    SQUARE("Square", 4);
+
+    private final String name;
+    private final int size;
+    FigureEnum(String name, int size) {
+        this.name = name;
+        this.size = size;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public int getSize(){
+        return this.size;
+    }
+}

src/main/java/figure/FigureFactory.java

@@ -0,0 +1,32 @@
+package figure;
+
+import java.lang.reflect.Constructor;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class FigureFactory {
+    private FigureFactory() {
+        throw new IllegalArgumentException("util class");
+    }
+
+    private static final Map<Integer, Class<? extends Figure>> figureMap = new HashMap<>();
+
+    static {
+        figureMap.put(FigureEnum.LINE.getSize(), Line.class);
+        figureMap.put(FigureEnum.TRIANGLE.getSize(), Triangle.class);
+        figureMap.put(FigureEnum.SQUARE.getSize(), Square.class);
+    }
+
+    public static Figure getInstance(List<Dot> points) {
+        Class<? extends Figure> figureClass = figureMap.get(points.size());
+        if (figureClass == null) {
+            throw new IllegalArgumentException("잘못된 입력");
+        }
+        try {
+            return figureClass.getConstructor(List.class).newInstance(points);
+        } catch (Exception e) {
+            throw new IllegalArgumentException("유효하지 않은 도형");
+        }
+    }
+}

src/main/java/figure/FigureFactoryLambda.java

@@ -0,0 +1,32 @@
+package figure;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Function;
+
+public class FigureFactoryLambda {
+    private FigureFactoryLambda() {
+        throw new IllegalArgumentException("util class");
+    }
+    private static final Map<Integer, Function<List<Dot>, Figure>> figureMap = new HashMap<>();
+    private static final Map<Integer, FactoryFunction> figureMap2 = new HashMap<>();
+    static {
+        figureMap2.put(2, Line::new);
+        figureMap2.put(3, Triangle::new);
+        figureMap2.put(4, Square::new);
+    }
+    static {
+        figureMap.put(2, Line::new);
+        figureMap.put(3, Triangle::new);
+        figureMap.put(4, Square::new);
+    }
+    public static Figure getInstance(List<Dot> dotList){
+        Function<List<Dot>, Figure> figureFunction = figureMap.get(dotList.size());
+        return figureFunction.apply(dotList);
+    }
+    public static Figure getInstanceByCustomFunction(List<Dot> dotList){
+        FactoryFunction factoryFunction = figureMap2.get(dotList.size());
+        return factoryFunction.create(dotList);
+    }
+}

src/main/java/figure/Line.java

@@ -0,0 +1,31 @@
+package figure;
+
+import java.util.List;
+
+public class Line extends AbstractFigure {
+
+    public Line(List<Dot> dotList) {
+        super(dotList);
+    }
+
+    @Override
+    public String getName() {
+        return FigureEnum.LINE.getName();
+    }
+
+    @Override
+    public int size() {
+        return FigureEnum.LINE.getSize();
+    }
+
+    @Override
+    public double getArea() {
+        return getLineDistance();
+    }
+
+    private double getLineDistance() {
+        Dot dot = this.getDot(0);
+        Dot secondDot = this.getDot(1);
+        return dot.getDistanceBetween(secondDot);
+    }
+}

src/main/java/figure/Square.java

@@ -0,0 +1,38 @@
+package figure;
+
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+public class Square extends AbstractFigure{
+
+    public Square(List<Dot> dotList) {
+        super(dotList);
+    }
+
+    @Override
+    public String getName() {
+        return FigureEnum.SQUARE.getName();
+    }
+
+    @Override
+    public int size() {
+        return FigureEnum.SQUARE.getSize();
+    }
+
+    @Override
+    public double getArea() {
+        return getSquareArea();
+    }
+
+    private double getSquareArea(){
+        List<Double> collect = IntStream.range(0, 4)
+                .mapToObj(i -> getDot(i).getDistanceBetween(getDots().get((i + 1) % 4)))
+                .distinct().collect(Collectors.toList());
+
+        if (collect.size() == 1) return (int) Math.pow(collect.get(0), 2);
+
+        return collect.get(0)  * collect.get(1);
+    }
+
+}

src/main/java/figure/Triangle.java

@@ -0,0 +1,46 @@
+package figure;
+
+import java.util.Arrays;
+import java.util.List;
+
+public class Triangle extends AbstractFigure{
+    public Triangle(List<Dot> dotList) {
+        super(dotList);
+    }
+
+    @Override
+    public String getName() {
+        return FigureEnum.TRIANGLE.getName();
+    }
+
+    @Override
+    public int size() {
+        return FigureEnum.TRIANGLE.getSize();
+    }
+
+    @Override
+    public double getArea() {
+        return calculateArea();
+    }
+    private double getLineLength(int firstIdx, int secondIdx){
+        Dot dot = getDot(firstIdx);
+        Dot secondDot = getDot(secondIdx);
+        return dot.getDistanceBetween(secondDot);
+    }
+
+    //헤론의 공식
+    //s = (a + b + c) / 2
+    //Area = √(s * (s - a) * (s - b) * (s - c))
+    private double calculateArea(){
+        double[] lengths = new double[3];
+
+        for (int i = 0; i < size(); i++) {
+            lengths[i] = this.getLineLength(i, (i + 1) % 3);
+        }
+
+        double s = Arrays.stream(lengths).sum() / 2;
+
+        return Math.sqrt(s * (s - lengths[0]) * (s - lengths[1]) * (s - lengths[2]));
+    }
+
+}

src/main/java/view/InputView.java

@@ -0,0 +1,17 @@
+package view;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+
+public class InputView {
+    private InputView() {
+        throw new IllegalArgumentException();
+    }
+
+    private static final BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+    public static String[] getInput() throws IOException {
+        String userInput = br.readLine();
+        return userInput.split("-");
+    }
+}

src/main/java/view/OutputView.java

@@ -0,0 +1,29 @@
+package view;
+
+import figure.Dot;
+import figure.Figure;
+import figure.FigureFactory;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class OutputView {
+    private OutputView() {
+        throw new IllegalArgumentException();
+    }
+
+    public static void printGetInput(){
+        System.out.println("숫자를 입력해라");
+    }
+
+    public static void printOutput(String[] userInputs){
+        List<Dot> dotList = new ArrayList<>();
+        for (String userInput : userInputs) {
+            dotList.add(Dot.of(userInput));
+        }
+        Figure instance = FigureFactory.getInstance(dotList);
+        String name = instance.getName();
+        double area = instance.getArea();
+        System.out.println(name + "의 Area 는 : " + area + "이다.");
+    }
+}