TIL - 2024/05/10

배운 내용 🏃

 

개인과제 계산기 level 2를 진행했다 ~2-10

 

요구사항 2-6

Calculator 인스턴스를 생성(new)할 때 생성자를 통해 연산 결과를

저장하고 있는 컬렉션 필드가 초기화 되도록 수정합니다.

 

요구사항 참고

public class Calculator {
		/* 연산 결과를 저장하는 컬렉션 타입 필드가 생성자를 통해 초기화 되도록 변경 */
		/* 생성자 구현 */
		...
}

public class App {
    public static void main(String[] args) {
        /* 위 요구사항에 맞게 Calculator 인스턴스 생성 부분 수정 */

        ...
    }
}

 

구현 코드

public class App {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        List<Integer> initialResults = new ArrayList<>(); // 초기 결과 리스트 생성
        Calculator calc = new Calculator(initialResults);
        }

public class Calculator {
    private List<Integer> results;

    public Calculator() {
        results = new ArrayList<>();
    }
    public Calculator(List<Integer> initialResults) {
        this.results = new ArrayList<>(initialResults);
    }

    public int calculate(int firstNumber, int secondNumber, char operator) throws InvalidCalculationException {
        int result = 0;
        switch (operator) {
            case '+':
                result = firstNumber + secondNumber;
                break;
            case '-':
                result = firstNumber - secondNumber;
                break;
            case '*':
                result = firstNumber * secondNumber;
                break;
            case '/':
                if (secondNumber == 0) {
                    throw new InvalidCalculationException("계산불가");
                }
                result = firstNumber / secondNumber;
                break;
            default:
                throw new InvalidCalculationException("연산기호가 잘못 됐습니다");
        }
        addResult(result); // 결과 추가
        return result;
    }

    public List<Integer> getResults() {
        return new ArrayList<>(results);
    }

    public void setResults(List<Integer> newResults) {
        this.results = new ArrayList<>(newResults);
    }

    public void addResult(int result) {
        results.add(result);
    }

    public void removeFirstResult() {
        if (!results.isEmpty()) {
            results.remove(0);
        }
    }
    public void inquiryResults() { //추가
        if (!results.isEmpty()) {
            System.out.println("저장된 모든 결과:");
            for (int res : results) {
                System.out.println(res);
            }
        } else {
            System.out.println("저장된 결과가 없습니다.");
        }
    }

}

요구사항 2-7

Calculator 클래스에 반지름을 매개변수로 전달받아

원의 넓이를 계산하여 반환해주는 메서드를 구현합니다.

 

• APP 클래스의 main 메서드에 Scanner를 활용하여 사칙연산을 진행할지

원의 넓이를 구할지 명령어를 입력 받은 후 원의 넓이를 구하는 것을 선택했을 때

원의 반지름을 입력 받아 원의 넓이를 구한 후 출력되도록 구현합니다

 

• 기존에 구현되어있던 사칙연산 기능은 수정 후에도 반드시 이전과 동일하게 동작해야합니다

• 이때, static, final 키워드를 활용할 수 있는지 고민한 후 활용 해봅니다

• 반드시 static, final 키워드에 대한 설명과 활용한 이유에 대해 주석으로 작성합니다

• 원의 넓이 결과를 저장하는 컬렉션 타입의 필드 선언 및 생성

• 계산된 원의 넓이를 저장합니다

• 생성자로 초기화됩니다

• 외부에서 직접 접근할 수 없습니다

• Getter, Setter 메서드를 구현합니다

• 원의 넓이 결과값들을 조회하는 메서드를 구현합니다

 

요구사항 참고

public class Calculator {
		/* static, final 활용 */
		/* 원의 넓이 결과를 저장하는 컬렉션 타입의 필드 선언 및 생성 */
		/* 생성자 수정 */
		...
		
		/* 원의 넓이를 구하는 메서드 선언*/
		public 반환타입 calculateCircleArea(매배변수) {
        /* 원의 넓이 계산 구현 */
    }
		/* 원의 넓이 저장 필드 Getter, Setter, 조회 메서드 구현 */
}

public class App {
    public static void main(String[] args) {
        /* Calculator 인스턴스 생성 */

        Scanner sc = new Scanner(System.in);

        /* 반복문 시작 */
            /* 사칙연산을 진행할지 원의 너비를 구할지 선택 구현 */
            ...
            /* 원의 넓이를 구하는 경우 반지름을 입력받아 원의 넓이를 구한 후 출력*/
            /* 원의 넓이 저장 */
            /* 저장된 원의 넓이 값들 바로 전체 조회 */
        
		        System.out.println("더 계산하시겠습니까? (exit 입력 시 종료)");
        /* 반복문 종료 */
    }
}

구현 코드

public class Calculator {
    private List<Integer> results;
    private List<Double> circleAreas;

    // 수정된 생성자
    public Calculator(List<Integer> initialResults, List<Double> initialCircleAreas) {
        this.results = new ArrayList<>(initialResults);
        this.circleAreas = new ArrayList<>(initialCircleAreas);
    }

    public double calculateCircleArea(double radius) {
        double area = Math.PI * radius * radius; // Math.PI 사용
        circleAreas.add(area);
        return area;
    }
    public int calculate(int firstNumber, int secondNumber, char operator) throws InvalidCalculationException {
        int result = 0;
        switch (operator) {
            case '+':
                result = firstNumber + secondNumber;
                break;
            case '-':
                result = firstNumber - secondNumber;
                break;
            case '*':
                result = firstNumber * secondNumber;
                break;
            case '/':
                if (secondNumber == 0) {
                    throw new InvalidCalculationException("계산불가");
                }
                result = firstNumber / secondNumber;
                break;
            default:
                throw new InvalidCalculationException("연산기호가 잘못 됐습니다");
        }
        addResult(result); // 결과 추가
        return result;
    }

    public List<Integer> getResults() {
        return new ArrayList<>(results);
    }

    public void setResults(List<Integer> newResults) {
        this.results = new ArrayList<>(newResults);
    }

    public void addResult(int result) {
        results.add(result);
    }

    public void removeFirstResult() {
        if (!results.isEmpty()) {
            results.remove(0);
        }
    }
    public void inquiryResults() { //추가
        if (!results.isEmpty()) {
            System.out.println("저장된 모든 결과:");
            for (int res : results) {
                System.out.println(res);
            }
        } else {
            System.out.println("저장된 결과가 없습니다.");
        }
    }
    public List<Double> getCircleAreas() {
        return new ArrayList<>(circleAreas);
    }
    public void setCircleAreas(List<Double> newCircleAreas) {
        this.circleAreas = new ArrayList<>(newCircleAreas);
    }
    public void inquiryCircleResults() { // 원의 넓이 결과 조회
        if (!circleAreas.isEmpty()) {
            System.out.println("저장된 원의 넓이 결과:");
            for (double area : circleAreas) {
                System.out.println(area);
            }
        } else {
            System.out.println("저장된 원의 넓이 결과가 없습니다.");
        }
    }

}

public class App {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        List<Integer> initialResults = new ArrayList<>();
        List<Double> initialCircleAreas = new ArrayList<>(); // 원의 넓이를 저장할 리스트 초기화
        Calculator calc = new Calculator(initialResults, initialCircleAreas);

        while (true) {
            System.out.println("계산을 계속하려면 'calc', 원의 넓이를 계산하려면 'circle'을 입력하세요: ");
            String command = sc.next();

            if (command.equalsIgnoreCase("circle")) {
                System.out.print("원의 반지름을 입력하세요: ");
                double radius = sc.nextDouble();
                double area = calc.calculateCircleArea(radius);
                System.out.println("원의 넓이: " + area);
                calc.inquiryCircleResults(); // 저장된 원의 넓이 결과 조회
            } else if (command.equalsIgnoreCase("calc")) {
                System.out.print("첫 번째 숫자를 입력하세요: ");
                int firstNumber = sc.nextInt();

                System.out.print("사칙연산 기호를 입력하세요: ");
                char operator = sc.next().charAt(0);

                System.out.print("두 번째 숫자를 입력하세요: ");
                int secondNumber = sc.nextInt();

                try {
                    int result = calc.calculate(firstNumber, secondNumber, operator);
                    System.out.println("결과: " + result);
                } catch (InvalidCalculationException e) {
                    System.out.println(e.getMessage());
                }

                System.out.println("현재 저장된 결과의 수: " + calc.getResults().size() + " " + calc.getResults());

                System.out.println("가장 먼저 저장된 연산 결과를 삭제하시겠습니까? (remove 입력 시 삭제)");
                String removeCmd = sc.next();
                if (removeCmd.equalsIgnoreCase("remove")) {
                    calc.removeFirstResult();
                    System.out.println("첫 번째 결과가 삭제되었습니다.");
                }

                System.out.println("저장된 연산 결과를 조회하시겠습니까? (inquiry 입력 시 조회)");
                String inquiryLook = sc.next();
                if (inquiryLook.equalsIgnoreCase("inquiry")) {
                    calc.inquiryResults(); // 변경
                }
            }

            System.out.println("더 계산하시겠습니까? ('exit'를 입력하면 종료합니다)");
            String input = sc.next();
            if (input.equalsIgnoreCase("exit")) {
                break;
            }
        }
        // 종료 시 최종 저장된 결과 출력
        System.out.println("최종 저장된 결과:");
        for (int res : calc.getResults()) {
            System.out.println(res);
        }
        sc.close();
    }
}

요구사항 2-8

사칙연산을 수행하는 계산기 ArithmeticCalculator 클래스와 원과 관련된 연산을

수행하는 계산기 CircleCalculator 클래스 2개를 구현합니다

 

• 기존에 만들어둔 Calculator 클래스를 수정합니다

• 수정한 Calculator 클래스를 활용하여 ArithmeticCalculator, CircleCalculator 클래스를 구현 해봅니다 (상속)

• 위 요구사항을 구현하게되면 App 클래스의 main 메서드에 오류가 발생할 겁니다

• 구현한 클래스들을 활용하여 오류가 발생하지 않고 활용될 수 있도록 수정 해보세요

• 기존에 사칙연산을 저장하던 컬렉션 필드의 타입을 Double로 변경해도 괜찮습니다

• 필드의 접근 제어자를 변경해도 괜찮습니다

 

※ 요구사항에 따라서 구현 하려고 했지만 제 코드가 꼭 정답은 아닙니다 

빼먹은 부분도 있습니다

 

참고 코드

public /* Hint */ class Calculator {
		/* 수정 */
}

public class ArithmeticCalculator /* Hint */ {
		/* 구현 */
}

public class CircleCalculator /* Hint */ {
		/* 구현 */
}

public class App {
    public static void main(String[] args) {
        /* 수정 */
    }
}

구현 코드

public class Calculator {
    private List<Double> results;  // Changed from List<Integer> to accommodate both integers and floating-point results
    private List<Double> circleAreas;

    public Calculator() {
        this.results = new ArrayList<>();
        this.circleAreas = new ArrayList<>();
    }

    public void addResult(double result) {
        results.add(result);
    }

    public List<Double> getResults() {
        return new ArrayList<>(results);
    }

    public void setResults(List<Double> newResults) {
        this.results = new ArrayList<>(newResults);
    }

    public void removeFirstResult() {
        if (!results.isEmpty()) {
            results.remove(0);
        }
    }

    public void inquiryResults() {
        if (!results.isEmpty()) {
            System.out.println("저장된 모든 결과:");
            for (double res : results) {
                System.out.println(res);
            }
        } else {
            System.out.println("저장된 결과가 없습니다.");
        }
    }

    public void addCircleArea(double area) {
        circleAreas.add(area);
    }

    public List<Double> getCircleAreas() {
        return new ArrayList<>(circleAreas);
    }
    
    public void setCircleAreas(List<Double> newCircleAreas) {
        this.circleAreas = new ArrayList<>(newCircleAreas);
    }
    
    public void inquiryCircleResults() {
        if (!circleAreas.isEmpty()) {
            System.out.println("저장된 원의 넓이 결과:");
            for (double area : circleAreas) {
                System.out.println(area);
            }
        } else {
            System.out.println("저장된 원의 넓이 결과가 없습니다.");
        }
    }
}

public class ArithmeticCalculator extends Calculator {

    public double calculate(double firstNumber, double secondNumber, char operator) throws InvalidCalculationException {
        double result;
        switch (operator) {
            case '+':
                result = firstNumber + secondNumber;
                break;
            case '-':
                result = firstNumber - secondNumber;
                break;
            case '*':
                result = firstNumber * secondNumber;
                break;
            case '/':
                if (secondNumber == 0) {
                    throw new InvalidCalculationException("Division by zero");
                }
                result = firstNumber / secondNumber;
                break;
            default:
                throw new InvalidCalculationException("Invalid operation");
        }
        addResult(result);
        return result;
    }
}

public class CircleCalculator extends Calculator {

    public double calculateCircleArea(double radius) {
        double area = Math.PI * radius * radius;
        addResult(area);
        return area;
    }
}

public class App {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        ArithmeticCalculator arithmeticCalc = new ArithmeticCalculator();
        CircleCalculator circleCalc = new CircleCalculator();

        while (true) {
            System.out.println("계산을 계속하려면 'calc', 원의 넓이를 계산하려면 'circle'을 입력하세요: ");
            String command = sc.next();

            if (command.equalsIgnoreCase("circle")) {
                System.out.print("원의 반지름을 입력하세요: ");
                double radius = sc.nextDouble();
                double area = circleCalc.calculateCircleArea(radius);
                System.out.println("원의 넓이: " + area);
                circleCalc.inquiryResults(); // 원의 넓이 결과 조회
            } else if (command.equalsIgnoreCase("calc")) {
                System.out.print("첫 번째 숫자를 입력하세요: ");
                double firstNumber = sc.nextDouble();

                System.out.print("사칙연산 기호를 입력하세요: ");
                char operator = sc.next().charAt(0);

                System.out.print("두 번째 숫자를 입력하세요: ");
                double secondNumber = sc.nextDouble();

                try {
                    double result = arithmeticCalc.calculate(firstNumber, secondNumber, operator);
                    System.out.println("결과: " + result);
                } catch (InvalidCalculationException e) {
                    System.out.println(e.getMessage());
                }

                System.out.println("현재 저장된 결과의 수: " + arithmeticCalc.getResults().size() + " " + arithmeticCalc.getResults());

                System.out.println("가장 먼저 저장된 연산 결과를 삭제하시겠습니까? (remove 입력 시 삭제)");
                String removeCmd = sc.next();
                if (removeCmd.equalsIgnoreCase("remove")) {
                    arithmeticCalc.removeFirstResult();
                    System.out.println("첫 번째 결과가 삭제되었습니다.");
                }

                System.out.println("저장된 연산 결과를 조회하시겠습니까? (inquiry 입력 시 조회)");
                String inquiryLook = sc.next();
                if (inquiryLook.equalsIgnoreCase("inquiry")) {
                    arithmeticCalc.inquiryResults();
                }
            }

            System.out.println("더 계산하시겠습니까? ('exit'를 입력하면 종료합니다)");
            String input = sc.next();
            if (input.equalsIgnoreCase("exit")) {
                break;
            }
        }
        System.out.println("최종 저장된 결과:");
        for (double res : arithmeticCalc.getResults()) {
            System.out.println(res);
        }
        sc.close();
    }
}

요구사항 2-9

ArithmeticCalculator 클래스의 연산 메서드에 책임(역할)이 많아 보입니다.

사칙연산 각각의 기능을 담당하는 AddOperator, SubtractOperator, MultiplyOperator, DivideOperator

클래스를 만들어 연산 메서드의 책임을 분리 해봅니다. (SRP)

• Calculator 클래스에 사칙연산 클래스들을 어떻게 활용할 수 있을지 고민 해봅니다. (포함 관계)

• 활용 방법을 찾아 적용했을 때 사칙연산 클래스들을 초기화 해야하는데 이때, 반드시 생성자를 활용해 봅니다

• 마찬가지로 ArithmeticCalculator 클래스의 연산 메서드를 수정 하더라도 이전과 똑같이 동작해야합니다

 

참고 코드

public class AddOperator {
    public int operate(매개변수) {
        /* 구현 */
    }
}

public class SubtractOperator {
    public int operate(매개변수) {
         /* 구현 */
    }
}

public class MultiplyOperator {
    public int operate(매개변수) {
         /* 구현 */
    }
}

public class DivideOperator {
    public int operate(매개변수) {
         /* 구현 */
    }
}

public class ArithmeticCalculator /* Hint */ {
		/* 수정 */
}

public class App {
    public static void main(String[] args) {
        /* 수정 */
    }
}

구현코드

public class AddOperation extends AbstractOperation {

    @Override
    public double operate(int firstNum, int secondNum) {
        return firstNum + secondNum;
    }
}

public class SubstractOperation extends AbstractOperation {
    @Override
    public double operate(int firstNum, int secondNum) {
        return firstNum - secondNum;
    }
}

public class MultiplyOperation extends AbstractOperation {

    @Override
    public double operate(int firstNum, int secondNum) {
        return firstNum * secondNum;
    }
}

public class DivideOperation extends AbstractOperation {
    @Override
    public double operate(int firstNum, int secondNum) {
        return firstNum / secondNum;
    }
}

public class ArithmeticCalculator extends Calculator {
    private AddOperation addOperation;
    private SubstractOperation substractOperation;
    private MultiplyOperation multiplyOperation;
    private DivideOperation divideOperation;

    public ArithmeticCalculator() {
        this.addOperation = new AddOperation();
        this.substractOperation = new SubstractOperation();
        this.multiplyOperation = new MultiplyOperation();
        this.divideOperation = new DivideOperation();
    }

    public double calculate(double firstNumber, double secondNumber, char operator) throws InvalidCalculationException {
        double result;
        switch (operator) {
            case '+':
                result = addOperation.operate((int)firstNumber, (int)secondNumber);
                break;
            case '-':
                result = substractOperation.operate((int)firstNumber, (int)secondNumber);
                break;
            case '*':
                result = multiplyOperation.operate((int)firstNumber, (int)secondNumber);
                break;
            case '/':
                if (secondNumber == 0) {
                    throw new InvalidCalculationException("계산불가");
                }
                result = divideOperation.operate((int)firstNumber, (int)secondNumber);
                break;
            default:
                throw new InvalidCalculationException("연산기호가 잘못 됐습니다");
        }
        addResult(result);
        return result;
    }
}

public class App {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        ArithmeticCalculator arithmeticCalc = new ArithmeticCalculator();
        CircleCalculator circleCalc = new CircleCalculator();

        while (true) {
            System.out.println("계산을 계속하려면 'calc', 원의 넓이를 계산하려면 'circle'을 입력하세요: ");
            String command = sc.next();

            if (command.equalsIgnoreCase("circle")) {
                System.out.print("원의 반지름을 입력하세요: ");
                double radius = sc.nextDouble();
                double area = circleCalc.calculateCircleArea(radius);
                System.out.println("원의 넓이: " + area);
                circleCalc.inquiryResults(); // 원의 넓이 결과 조회
            } else if (command.equalsIgnoreCase("calc")) {
                System.out.print("첫 번째 숫자를 입력하세요: ");
                double firstNumber = sc.nextDouble();

                System.out.print("사칙연산 기호를 입력하세요: ");
                char operator = sc.next().charAt(0);

                System.out.print("두 번째 숫자를 입력하세요: ");
                double secondNumber = sc.nextDouble();

                try {
                    double result = arithmeticCalc.calculate(firstNumber, secondNumber, operator);
                    System.out.println("결과: " + result);
                } catch (InvalidCalculationException e) {
                    System.out.println(e.getMessage());
                }

                System.out.println("현재 저장된 결과의 수: " + arithmeticCalc.getResults().size() + " " + arithmeticCalc.getResults());

                System.out.println("가장 먼저 저장된 연산 결과를 삭제하시겠습니까? (remove 입력 시 삭제)");
                String removeCmd = sc.next();
                if (removeCmd.equalsIgnoreCase("remove")) {
                    arithmeticCalc.removeFirstResult();
                    System.out.println("첫 번째 결과가 삭제되었습니다.");
                }

                System.out.println("저장된 연산 결과를 조회하시겠습니까? (inquiry 입력 시 조회)");
                String inquiryLook = sc.next();
                if (inquiryLook.equalsIgnoreCase("inquiry")) {
                    arithmeticCalc.inquiryResults();
                }
            }

            System.out.println("더 계산하시겠습니까? ('exit'를 입력하면 종료합니다)");
            String input = sc.next();
            if (input.equalsIgnoreCase("exit")) {
                break;
            }
        }
        System.out.println("최종 저장된 결과:");
        for (double res : arithmeticCalc.getResults()) {
            System.out.println(res);
        }
        sc.close();
    }
}

요구사항 2-10

ArithmeticCalculator 클래스에 추가로 나머지 연산(%) 기능을 추가하기 위해

ModOperator 클래스를 만들어 추가합니다

 

• 추가하려고 하니 앞으로 계속 기능이 추가되면 여러 부분의 소스코드를 수정해야

한다는 생각이 들었고 “현재 비효율적인 구조가 아닌가?” 라는 의구심이 들었습니다

• 따라서 소스 코드의 변경은 최소화하면서 기능을 쉽게 추가(확장)할 수 있는 방법을 고민 해봅니다 (OCP)

• 방법을 고민 및 학습하여 적용했을 때 전체적인 소스 코드와 구조의 변경이 발생 했을 겁니다

•  최대한 생각한 방법으로 구현 해보세요. 틀린 답은 없습니다.

컴파일에 문제가 없고 기능이 정상적으로 동작 하면 모두 정답입니다

• 포기하는 것 보다 본인이 생각한데로 구현해보고 다른 개발자들과

공유 하면서 여러 가지 방법들을 확인 했을 때 실력이 가장 많이 향상됩니다

• 마찬가지로 수정 후에도 이전과 똑같이 동작해야합니다

 

참고 코드

/* Hint : Interface & (다형성의 원리) 등을 활용 */

public class ModOperator /* Hint */ {
    public int operate(매개변수) {
        /* 구현 */
    }
}

public class AddOperator /* Hint */ {
    public int operate(매개변수) {
        ...
    }
}

public class SubtractOperator /* Hint */ {
    public int operate(매개변수) {
         ...
    }
}

public class MultiplyOperator /* Hint */ {
    public int operate(매개변수) {
         ...
    }
}


public class DivideOperator /* Hint */ {
    public int operate(매개변수) {
        ...
    }
}

public class ArithmeticCalculator /* Hint */ {
		/* 수정 */
}

public class App {
    public static void main(String[] args) {
        /* 수정 */
    }
}

구현코드

public class ModOperation implements IOperation {
    @Override
    public double operate(int firstNum, int secondNum) {
        if (secondNum == 0) throw new IllegalArgumentException("계산불가");
        return firstNum % secondNum;
    }
}

public class AddOperation implements IOperation {
    @Override
    public double operate(int firstNum, int secondNum) {
        return firstNum + secondNum;
    }
}

public class SubstractOperation implements IOperation {
    @Override
    public double operate(int firstNum, int secondNum) {
        return firstNum - secondNum;
    }
}

public class MultiplyOperation implements IOperation {
    @Override
    public double operate(int firstNum, int secondNum) {
        return firstNum * secondNum;
    }
}

public class DivideOperation implements IOperation {
    @Override
    public double operate(int firstNum, int secondNum) {
        if (secondNum == 0) throw new IllegalArgumentException("계산불가");
        return firstNum / secondNum;
    }
}

public class ArithmeticCalculator {
    private Map<Character, IOperation> operations;
    private List<Double> results = new ArrayList<>();

    public ArithmeticCalculator() {
        operations = Map.of(
                '+', new AddOperation(),
                '-', new SubstractOperation(),
                '*', new MultiplyOperation(),
                '/', new DivideOperation(),
                '%', new ModOperation()  // 예를 들어 나머지 연산을 추가할 수 있음
        );
    }

    public double calculate(double firstNumber, double secondNumber, char operator) throws InvalidCalculationException {
        IOperation operation = operations.get(operator);
        if (operation == null) {
            throw new InvalidCalculationException("잘못됨: " + operator);
        }
        double result = operation.operate((int) firstNumber, (int) secondNumber);
        results.add(result); // 결과를 저장
        return result;
    }

    // 결과 목록을 반환하는 메소드
    public List<Double> getResults() {
        return results;
    }

    // 첫 번째 결과를 삭제하는 메소드
    public void removeFirstResult() {
        if (!results.isEmpty()) {
            results.remove(0);
        }
    }

    // 결과 목록을 출력하는 메소드
    public void inquiryResults() {
        if (!results.isEmpty()) {
            System.out.println("저장된 결과:");
            for (Double result : results) {
                System.out.println(result);
            }
        } else {
            System.out.println("저장된 결과가 없습니다.");
        }
    }
}

 

마무리🔥

개인과제 2-10까지 진행했다. level 3도있지만 매우 어렵고 시간이 없어서 못했다

내 코드를보고 튜터님께서 피드백을 주셨다

 

튜터님 피드백: level1은 모든 요구 사항에 맞게 잘 구현하셨다

다음으로 레벨2에 대한 피드백을 드리자면 확실히 추상화를 아직 어려워하시는 것 같아요

Calculator 는 abstract class 로 선언하여 이를 상속할 하위 클래스들에서 공통적으로 사용될만한 메서드와 변수만 선언하는 것이 좋습니다 ! (ex : getResults(), removeFirstResult() 등) 따라서 아래 변수들을 모두 선언하지 않고, 공통적으로 쓰이는 변수(ex - ArrayList<Double> resultList;)만 남기셔야 합니다 !

private List<Double> results; private List<Double> circleAreas; 이 후, 아래 코드처럼 생성자를 통하여 부모 클래스의 result 를 쓰는 로직을 추가하게 된다면 Calculator 에서 더 이상 아래 멤버변수들을 가질 필요 없이 부모 클래스(Calculator)의 results 를 사용할 수 있게 됩니다 ! public ArithmeticCalculator(List<Double> results, Class<T> type) { super(results); this.type = type; } 추가적으로 레벨 2의 요구사항 중 static final 키워드를 사용을 안하셨네요 ㅠㅠ static final double PI =3.14 이런 식으로 PI 값을 선언하게 하기 위한 요구사항이었는데 Math 라이브러리에서 제공하는 PI 를 사용하셨더라구요 ! 물론 잘못된 건 아닙니다 ㅎㅎ 라이브러리에서 제공해주는 메서드를 쓰는 습관은 좋은 습관이에요 ! 사실상 PI 는 CircleCalculator 에서만 쓰일 상수기 때문에, 공통 변수를 남겨야 할 Calculator 에 선언하는 것보단 CircleCalculator 에 선언하시면 됩니다 ! 그리고 AbstractOperation -> interface IOperation 로 대체하신 것 같은데 아주 좋습니다 ! 다만 더 이상 사용되지 않는 클래스는 삭제해주시면 추후 규모가 커질 시에, 혼동이 적을 것 같습니다 

 

>> >> 무슨말씀인지 이해를 했다 코드 리팩토링할때 튜터님 피드백 보고 다시 고쳐야겠다

과제가 어렵다고 느꼈다 보니 요구사항을 많이 빠트린거 같다

다시한번 공부를 더 해야할거같다

 

그리고 1주일동안 팀 프로젝트를 진행했다

그에 대한 kpt 회고를 작성했다

팀 프로젝트 kpt 회고 게시글