📚 TIL 8일차

오늘 주요 사항 (5/24, 수요일)

1. Git 특강
2. Java 문법 학습
   • 객체지향 (SOLID)
   • 추상 클래스 vs 인터페이스

[Git 특강] Pull request 연습

앞으로도 많은 도움이 될 것 같아서 글을 따로 정리해두었다.
🐱 [Git] Pull request 연습

지금까지 배운 내용 복습 : 계산기 구현

Step 1

아래의 클래스 다이어그램과 조건을 참고하여 기능을 구현해보자.

[클래스 다이어그램]

[조건]

1. 계산기는 덧셈, 뺄셈, 나눗셈, 곱셈 연산을 수행한다.
2. calculate() 메서드는 String 타입의 operator 매개변수를 통해 연산자 매개값을 받는다.
3. int 타입의 firstNumber, secondNumber 매개변수를 통해 피연산자 값을 받는다.
4. 전달받은 피연산자, 연산자를 사용하여 연산을 수행한다.

📁 Calculate.java

public class Calculator {

	/* 계산 메서드 */
    double calculate(String operator, int firstNumber, int secondNumber) {

        double result = 0;

		// operator를 통해 넘어오는 연산자를 비교해
        // 그에 맞는 연산을 실행한다.
        switch(operator) {
            case "+":
                result = firstNumber + secondNumber;
                break;
            case "-":
                result = firstNumber - secondNumber;
                break;
            case "/":
                result = firstNumber / secondNumber;
                break;
            case "*":
                result = firstNumber * secondNumber;
                break;
        }

        return result;
    }
}

📁 Main.java

public class Main {
    public static void main(String[] args) {

        Calculator cal = new Calculator();

		// cal.calculate(String, int, int)
        System.out.println("add: " + cal.calculate("+", 10, 10));
        System.out.println("sub: " + cal.calculate("-", 7, 10));
        System.out.println("div: " + cal.calculate("/", 5, 2));
        System.out.println("mul: " + cal.calculate("*", 7, 9));
    }
}

▶️ 실행 결과

add: 20.0
sub: -3.0
div: 2.0
mul: 63.0

Step 2

[클래스 다이어그램]

[조건]

1. 덧셈, 뺄셈, 나눗셈, 곱셈 연산을 수행할 클래스들을 만든다.
2. 만든 후 Calculator 클래스와 관계를 맺는다. (Is-a, Has-a 등)
3. 필요하다면 Calculator 클래스의 내부코드를 변경한다.

📁 ~~~Operation.java : 연산 클래스

메서드를 복사해서 중간 연산자만 바꿔 메서드를 생성한다. 연산자만 다르고, 작업은 반복되기 때문에 비효율적으로 보인다.

/* AddOperation.java */
public double operate(int firstNumber, int secondNumber) {

        return firstNumber + secondNumber;
}

/* SubstractOperation.java */
public double operate(int firstNumber, int secondNumber) {

        return firstNumber - secondNumber;
}

/* DivideOperation.java */
public double operate(int firstNumber, int secondNumber) {

        return firstNumber / secondNumber;
}

/* MultiplyOperation.java */
public double operate(int firstNumber, int secondNumber) {

        return firstNumber * secondNumber;
}

📁 Calculate.java

public class Calculator {

    /* 덧셈 */
    public AddOperation addOperation = new AddOperation();
    /* 뺄셈 */
    public SubstractOperation substractOperation = new SubstractOperation();
    /* 나눗셈 */
    public DivideOperation divideOperation = new DivideOperation();
    /* 곱셈 */
    public MultiplyOperation multiplyOperation = new MultiplyOperation();

	/* 계산 메서드 */
    double calculate(String operator, int firstNumber, int secondNumber) {

        double result = 0;

		// operator를 통해 넘어오는 연산자를 비교해
        // 그에 맞는 연산 클래스의 operate() 함수를 호출한다.
        switch(operator) {
            case "+":
            	// result = firstNumber + secondNumber;
                result = addOperation.operate(firstNumber, secondNumber);
                break;
            case "-":
            	// result = firstNumber - secondNumber;
                result = substractOperation.operate(firstNumber, secondNumber);
                break;
            case "/":
            	// result = firstNumber / secondNumber;
                result = divideOperation.operate(firstNumber, secondNumber);
                break;
            case "*":
            	// result = firstNumber * secondNumber;
                result = multiplyOperation.operate(firstNumber, secondNumber);
                break;
        }

        return result;
    }
}

📁 Main.java

public class Main {
    public static void main(String[] args) {

		// Calculator 객체 생성
        Calculator cal = new Calculator();

		// cal.calculate(String, int, int)
        System.out.println("add: " + cal.calculate("+", 10, 10));
        System.out.println("sub: " + cal.calculate("-", 7, 10));
        System.out.println("div: " + cal.calculate("/", 5, 2));
        System.out.println("mul: " + cal.calculate("*", 7, 9));
    }
}

▶️ 실행 결과

add: 20.0
sub: -3.0
div: 2.0
mul: 63.0

🤔❓ Step 1과 비교하여 어떠한 점이 개선 되었는지 스스로 생각해 봅니다.

💡 hint. 클래스의 책임 (단일책임원칙)

[A] 기존 'Step 1'에서는 Calculator 클래스의 calculate() 메서드가 연산자 비교와 연산 작업을 모두 맡았다. 이는 하나의 클래스는 하나의 책임만을 져야한다는 객체지향 단일책임원칙에 위배된다.

'Step 2'로 코드를 변경하면서는 각 연산 클래스들이 덧셈, 뺄셈, 나눗셈, 곱셈 중 한가지 씩 수행을 하고 있고, calculate() 메서드는 연산자 비교만을 담당하고 있다.

Step 3

[클래스 다이어그램]

[조건]

1. Step 2에서 만든 연산 클래스들을 추상 클래스를 사용하여 추상화한다.
2. 추상화한 후, Calculator 클래스의 내부 코드를 변경한다.
3. Calculator의 calculate() 메서드의 매개변수가 변경되었음을 확인.

📁 AbstractOperation.java : 추상 클래스

순간 추상 클래스를 인터페이스라고 알아들어서 ^^;; 도중에 이해가 꼬이는 바람에 이상한 곳에서 시간을 버렸다. abstract와 interface를 앞으로는 헷갈리지 말자! 물론 interface를 사용했어도 문제없이 구현됐을 것이다.

public abstract class AbstractOperation { 
	
    // 내용은 구현하지 않아도 괜찮다.
	public abstract double operate(int firstNumber, int secondNumber);

}

📁 ~~~Operation.java : 연산 클래스

위의 AbstractOperation 클래스를 상속 받는다. 각 클래스 내부의 메서드는 Step 2와 동일하다.

/* AddOperation.java */
public class AddOperation extends AbstractOperation { }

/* SubstractOperation.java */
public class SubstractOperation extends AbstractOperation { }

/* DivideOperation.java */
public class DivideOperation extends AbstractOperation { }

/* MultiplyOperation.java */
public class MultiplyOperation extends AbstractOperation { }

📁 Calculate.java

	// 추상 클래스를 선언해 하위 클래스로부터의 형변환을 이용할 것이다.
    AbstractOperation operation;

	// setter()를 사용해 연산자를 설정한다.
    public void setOperation(AbstractOperation operation) {
        this.operation = operation;
    }

	// calculate() 메서드의 매개변수에서
    // 연산자를 받아오는 String 변수가 사라져
    // 이 메서드는 연산을 호출하는 일만을 하게 되었다.
    double calculate(int firstNumber, int secondNumber) {

        return operation.operate(firstNumber, secondNumber);
    }

📁 Main.java

public static void main(String[] args) {

	// 연산에 사용할 연산자 (덧셈)
	AbstractOperation addOperation = new AddOperation();
	// Calculator 객체 생성
	Calculator cal = new Calculator();

	// Calculator의 연산자 설정
	cal.setOperation(addOperation);
	// 결과 출력
	System.out.println("add: " + cal.calculate(10, 10));

	// 연산에 사용할 연산자 (곱셈)
	AbstractOperation multiflyOperation = new MultiplyOperation();
	
    // Calculator의 연산자 설정
	cal.setOperation(multiflyOperation);
	// 결과 출력
	System.out.println("mul: " + cal.calculate(7, 9));
}

▶️ 실행 결과

add: 20.0
mul: 63.0

🤔❓ Step 2와 비교해서 어떠한 점이 개선 되었는지 스스로 생각해 봅니다.

💡 hint. 클래스 간의 결합도, 의존성 (의존성역전원칙)

[A] 기존 'Step 2'에서는 각 클래스가 가지는 책임(수행)을 분담하는 것에 성공하였다. 하지만 Step 2를 다시 보면, Calculate 클래스와 연산 클래스 간 결합도가 높은 것을 볼 수 있다.

'Step 3'에서는 추상 클래스인 AbstractOperation을 만들어, 다른 연산 클래스들이 추상 클래스를 상속 받을 수 있도록 했다. 그런 다음 Calculate 클래스와 AbstractOperation 클래스가 포함 관계를 맺으면 결합도가 낮아진다. (추상 클래스는 하위 클래스로의 형변환이 가능하다)

그리고 Caculate 클래스는 구체화된(=구현부) 연산 클래스에 기능을 의존하고 있었다. 이는 객체지향 원칙 중, '구체적인 것이 아니라 추상화된 것에 의존하라'는 의존성 역전의 원칙의 위배된다.

의존성 역전의 원칙(DIP)를 지키는 이유는, 수정에 용이하게 하기 위함이다. 구현부 클래스(구체화된 클래스)는 코드 변화에 영향을 크게 받기 때문에 그 클래스에 의존하고 있는 클래스도 영향을 받게 된다.

하지만 구현부의 상위에 있는 추상 클래스는 영향을 받을 일이 적기 때문에, 추상 클래스에 의존하는 것이 구조상 바람직하다는 것이다.

기존 연산 클래스들 대신 추상 클래스를 포함하고, 연산자는 매개변수가 아닌 setter (setOperation() 메서드)를 통해 설정하도록 했다. 'Step 3'에서는 Main에서 사용할 연산자를 생성하고, Calculator 클래스의 setter를 통해 연산자를 전달한다. 연산 결과를 출력할 때는 연산이 필요한 firstNumber와 secondNumber만 Calculator.operate() 메서드로 전달해주면 된다.

후일담

Step 1→2로부터의 변화와, Step 2→3로부터의 변화를 SOLID와 엮어서 설명하려면 따로 객체지향원칙에 대한 학습이 필요해서 시간이 오래걸렸다.

하지만 미루면 다음에 내가 해두리란 보장도 없을 것 같고... 꼭 하고 잠들고 싶었기 때문에 하고 나니 기분은 좋다! (^─^)

추상 클래스와 인터페이스

추가로 'Step 3'의 추상 클래스에서 -> 인터페이스 형태로 바꾸는 것은 어렵지 않다. 아래처럼만 바꿔주면 끝!

public interface AbstractOperation {

    public double operate(int firstNumber, int secondNumber);
}

// 다른 연산 클래스들도 이렇게 해주면 된다.
public class AddOperation implements AbstractOperation {  /* 메서드는 그대로 */ }

그렇다면 이렇게 보면 차이가 없는데, 둘은 어떻게 구분해서 쓰는 걸까? 또, 왜 이 계산기 문제에서는 추상 클래스를 사용하라고 했을까? 같은 의문점이 생긴다...

출처: 자바의 추상 클래스와 인터페이스

Q. 둘은 어떻게 구분해서 쓰는 걸까?

추상 클래스와 인터페이스는 존재 목적이 다르다.

추상 클래스의 목적은 그 추상 클래스를 상속 받아서 기능을 사용하고, 확장시키는데 있다. 반면, 인터페이스의 목적은 명시한 함수의 구현을 강제하는데 있다. 구현을 강제함으로써 구현 객체의 동일한 동작을 보장할 수 있는 것이다.

즉, 상속을 받아서 기능을 사용하고 확장 시키려면 추상 클래스를, 명시한 기능을 구현하는 것이 목적이라면 인터페이스를 사용하면 된다.

Q. 이 계산기 문제에서는 왜 추상 클래스를 사용하라고 했을까?

보는 시각에 따라 구현 요구사항에 차이가 생긴 것 같다. (추측) 윗 문단에 따르면 아마 기능을 사용하는데에 좀 더 집중한 것은 아닐까? 나는 [조건]을 처음 읽었을 때, '기능을 구현한다'에 초점을 두고 읽어서 추상 클래스를 인터페이스로 오독했었다.

Java는 다중 상속을 지원하지 않는다.

상위 클래스가 같은 이름의 메서드를 가지고 있는 경우에는, 실행 시에 실제로 어떤 메서드가 실행될지 모호성이 생겨버린다. Java는 이 모호성을 미연에 방지하기 위해 다중 상속을 지원하지 않는다고 한다.

하지만 인터페이스는 아래처럼 여러 인터페이스를 받아와서 구현할 수 있다. (이는 상속이 아니다!!)

class Car implements vehicle, engine {}