조영준 report 5,6,7,8 push 하였습니다.

src/choyoungjun/SOLID/DIP.java

@@ -0,0 +1,119 @@
+package choyoungjun.SOLID;
+//원칙 적용 방법
+//고수준 모듈의 변화되는 부분을 추상화합니다.
+//저수준 모듈을 추상화에 의존시킵니다.
+//계산기 클래스에 추상화된 부모 클래스를 포함시킵니다. ok
+//연산 클래스는 추상화된 부모 클래스를 상속받아 기능별로 구현합니다. ok
+
+//문제
+//계산기(고수준 모듈)가 개별 연산 클래스(저수준 모듈)을 포함하며 계산 기능을 구현할 때 연산 클래스에 의존하고 있습니다.
+//저수준 모듈에서 변경이 발생되면 고수준 모듈에 수정사항이 발생합니다.
+
+import java.util.HashMap;
+import java.util.Map;
+
+//클라이언트는 calculator를 통해 통신해야 한다.
+public class DIP {
+    public static void main(String[] args) throws InstantiationException, IllegalAccessException {
+        Calculator calculator = new Calculator(
+                new AddOperation(),
+                new SubstractOperation(),
+                new MultiplyOperation(),
+                new DivideOperation()
+        );
+
+        int firNum = 140;
+        int secNum = 60;
+
+        String operator = "+";
+        int answer = calculator.calculate(operator, firNum, secNum);
+        System.out.println(operator + " answer = " + answer);
+
+        operator = "-";
+        answer = calculator.calculate(operator, firNum, secNum);
+        System.out.println(operator + " answer = " + answer);
+
+        operator = "*";
+        answer = calculator.calculate(operator, firNum, secNum);
+        System.out.println(operator + " answer = " + answer);
+
+        operator = "/";
+        answer = calculator.calculate(operator, firNum, secNum);
+        System.out.println(operator + " answer = " + answer);
+    }
+}
+class Calculator {
+
+    private AbstractOperation abstractOperation;
+
+    Map<String, AbstractOperation> abstractOperationMap = new HashMap<>();
+    public Calculator(AbstractOperation...abstractOperations) throws InstantiationException, IllegalAccessException {
+        for (AbstractOperation abstractOperation : abstractOperations){
+            abstractOperationMap.put(abstractOperation.getOperator(), abstractOperation.getClass().newInstance());
+        }
+    }
+
+    public void setAbstractOperation(AbstractOperation abstractOperation) {
+        this.abstractOperation = abstractOperation;
+    }
+
+    public int calculate(String operator, int firstNumber, int secondNumber) {
+        int answer = 0; // 문제 : operator라는 string과 그 주인장을 연결시켜야 함
+        abstractOperation = abstractOperationMap.get(operator);
+        answer = abstractOperation.operate(firstNumber, secondNumber);
+        return answer;
+    }
+}
+abstract class AbstractOperation{
+    private String operator;
+
+    public abstract int operate(int firstNumber, int secondNumber);
+
+    public String getOperator() {
+        return operator;
+    }
+
+    public void setOperator(String operator) {
+        this.operator = operator;
+    }
+
+}
+
+class AddOperation extends AbstractOperation{
+    AddOperation(){
+        this.setOperator("+");
+    }
+    @Override
+    public int operate(int firstNumber, int secondNumber){
+        return firstNumber + secondNumber;
+    }
+}
+class SubstractOperation extends AbstractOperation {
+    SubstractOperation(){
+        this.setOperator("-");
+    }
+    @Override
+    public int operate(int firstNumber, int secondNumber){
+        return firstNumber - secondNumber;
+    }
+}
+
+class MultiplyOperation extends AbstractOperation{
+    MultiplyOperation(){
+        this.setOperator("*");
+    }
+    @Override
+    public int operate(int firstNumber, int secondNumber){
+        return firstNumber * secondNumber;
+    }
+}
+
+class DivideOperation extends AbstractOperation{
+    DivideOperation(){
+        this.setOperator("/");
+    }
+    @Override
+    public int operate(int firstNumber, int secondNumber){
+        return firstNumber / secondNumber;
+    }
+}

src/choyoungjun/SOLID/ISP.java

@@ -0,0 +1,104 @@
+package choyoungjun.SOLID;
+
+public class ISP {
+    public static void main(String[] args) {
+        int firNum = 140;
+        int secNum = 60;
+
+        // 연산 결과만 출력
+        DisplayTypeA displayTypeA = new DisplayTypeA();
+        displayTypeA.displayResult(new AddOperation(), firNum, secNum);
+
+        // 연산 과정까지 출력
+        DisplayTypeB displayTypeB = new DisplayTypeB();
+        displayTypeB.displayResultWithOperator(new AddOperation(), firNum, secNum);
+    }
+}
+class Calculator {
+    public int calculate(AbstractOperation operation, int firstNumber, int secondNumber){
+        return operation.operate(firstNumber, secondNumber);
+    }
+}
+
+abstract class AbstractOperation {
+    public abstract int operate(int firstNumber, int secondNumber);
+    public abstract String getOperator();
+}
+
+interface DisplayResult {
+    void displayResult(AbstractOperation operation, int firstNumber, int secondNumber) throws Exception;
+}
+
+interface DisplayWithOperator{
+    void displayResultWithOperator(AbstractOperation operation, int firstNumber, int secondNumber) throws Exception;
+}
+
+// 연산 결과만 출력
+class DisplayTypeA extends Calculator implements DisplayResult {
+
+    @Override
+    public void displayResult(AbstractOperation operation, int firstNumber, int secondNumber) {
+        int answer = operation.operate(firstNumber, secondNumber);
+        System.out.println(answer);
+    }
+
+}
+
+// 연산 과정을 포함한 출력
+class DisplayTypeB extends Calculator implements DisplayWithOperator {
+
+    @Override
+    public void displayResultWithOperator(AbstractOperation operation, int firstNumber, int secondNumber) {
+        int answer = operation.operate(firstNumber, secondNumber);
+        String operator = operation.getOperator();
+        System.out.println(firstNumber + " " + operator + " " + secondNumber + " = " + answer);
+    }
+}
+
+class AddOperation extends AbstractOperation {
+    @Override
+    public int operate(int firstNumber, int secondNumber) {
+        return firstNumber + secondNumber;
+    }
+
+    @Override
+    public String getOperator() {
+        return "+";
+    }
+}
+
+class SubstractOperation extends AbstractOperation {
+    @Override
+    public int operate(int firstNumber, int secondNumber) {
+        return firstNumber - secondNumber;
+    }
+
+    @Override
+    public String getOperator() {
+        return "-";
+    }
+}
+
+class MultiplyOperation extends AbstractOperation {
+    @Override
+    public int operate(int firstNumber, int secondNumber) {
+        return firstNumber * secondNumber;
+    }
+
+    @Override
+    public String getOperator() {
+        return "*";
+    }
+}
+
+class DivideOperation extends AbstractOperation {
+    @Override
+    public int operate(int firstNumber, int secondNumber) {
+        return firstNumber / secondNumber;
+    }
+
+    @Override
+    public String getOperator() {
+        return "/";
+    }
+}

src/choyoungjun/SOLID/LSP.java

@@ -0,0 +1,74 @@
+package choyoungjun.SOLID;
+
+//원칙 적용 방법
+//부모 와 자식 클래스 사이의 행위가 일관성이 있도록 추상화를 좀 더 정교하게 구현합니다.
+//연산 기능을 추상화한 부모 클래스에 피연산자 값의 유효성 검사를 진행하는 메서드를 추가해 줍니다.
+//계산기 클래스에서는 이 메서드를 사용하여 유효성 검사를 진행하고 이 유효성 검사가 필요한 자식 클래스에서는 이 추가된 유효성 검사 조건을 구체화 합니다.
+//isInvalid : 추상 메서드
+
+public class LSP {
+    public static void main(String[] args) {
+        Calculator calculator = new Calculator();
+
+        int firNum = 140;
+        int secNum = 0;
+
+        int answer = calculator.calculate(new AddOperation(), firNum, secNum);
+        System.out.println(" + answer = " + answer);
+
+        answer = calculator.calculate(new SubstractOperation(), firNum, secNum);
+        System.out.println(" - answer = " + answer);
+
+        answer = calculator.calculate(new MultiplyOperation(), firNum, secNum);
+        System.out.println(" * answer = " + answer);
+
+        answer = calculator.calculate(new DivideOperation(), firNum, secNum);
+        System.out.println(" / answer = " + answer);
+    }
+}
+
+class Calculator {
+    // 연산 기능을 추상화된 부모클래스에 의존하여 처리한다.
+    public int calculate(AbstractOperation operation, int firstNumber, int secondNumber) {
+        if (!operation.isValid(firstNumber, secondNumber)) return -99999;
+        return operation.operate(firstNumber, secondNumber);
+    }
+}
+
+abstract class AbstractOperation {
+    public boolean isValid(int firstNumber, int secondNumber){return true;}
+    public abstract int operate(int firstNumber, int secondNumber);
+}
+
+class AddOperation extends AbstractOperation {
+    @Override
+    public int operate(int firstNumber, int secondNumber) {
+        return firstNumber + secondNumber;
+    }
+}
+
+class SubstractOperation extends AbstractOperation {
+    @Override
+    public int operate(int firstNumber, int secondNumber) {
+        return firstNumber - secondNumber;
+    }
+}
+
+class MultiplyOperation extends AbstractOperation {
+    @Override
+    public int operate(int firstNumber, int secondNumber) {
+        return firstNumber * secondNumber;
+    }
+}
+
+class DivideOperation extends AbstractOperation {
+    @Override
+    public int operate(int firstNumber, int secondNumber) {
+        return firstNumber/secondNumber;
+    }
+    @Override
+    public boolean isValid(int firstNumber, int secondNumber) {
+        if (secondNumber==0) return false;
+        return true;
+    }
+}