[객사오] 코드로 알아보는 객체의 "역할, 책임, 협력"

📚객체지향의 사실과 오해

 

객체지향 공부를 하기 위해 <객체지향의 사실과 오해>를 읽기 시작했다.

책의 내용을 무작정 정리하기 보다는, 내가 이 책을 읽고 더 공부하고 싶은 부분을 직접 딥다이브 해 볼 생각이다.

 

이번에 읽은 챕터는 [01. 협력하는 객체들의 공동체]로 객체지향의 본질에 대해 파고든다.

 

객체지향적으로 잘 짠 코드는 무엇일까?

• 객체는 충분히 '협력적'이어야 한다. 다른 객체의 요청에 충실히 응답하고, 다른 객체에게 적극적으로 도움을 요청할 수 있어야 한다는 것이다. 
• 객체가 충분히 '자율적'이어야 한다. 본인 스스로의 원칙에 따라 어떤 일을 하거나 자기 스스로 통제하여 절제하는 것을 의미한다. 

'객체의 자율성'에 대해 보충 설명을 하자면, 객체의 내부와 외부를 명확하게 구분하는 것이다.

객체의 사적인 부분은 객체 스스로 관리하고 외부에서 일체 간섭할 수 없도록 차단해야 하며, 객체의 외부에서는 접근이 허락된 수단을 통해서만 객체와 의사소통해야 한다.

 

이렇게만 보면 대충 이해는 갈 테지만 코드로 보면 또 느낌이 다르기 때문에 예시를 들어 설명해보겠다.

 

코드로 알아보기

식당 스태프가 밥을 먹은 손님에게 결제를 요청하는 상황이다. 현금 결제가 식당에게 이득이기 때문에 스태프는 손님이 현금을 소지하고 있으면 현금으로, 없으면 카드로 결제를 부탁하고자 한다.

 

먼저 현금의 가격을 Cash 클래스로 구현하였다.

public class Cash {
    private int cashAmount;

    public int getCashAmount() {
        return cashAmount;
    }
}

 

카드도 똑같이 Credit 클래스로 구현해 준다.

public class Credit {
    private int creditAmount;

    public int getCreditAmount() {
        return creditAmount;
    }
}

 

손님은 가방에 현금만 가지고 있을 수도, 카드만 가지고 있을 수도, 혹은 둘다 가지고 있을 수 있다. 이를 제약해주기 위해 아래처럼 3개의 생성자 경우의 수가 있는 가방 Bag 클래스를 만들어주었다.

public class Bag {
    private Cash cash;
    private Credit credit;

    public Bag(Cash cash) {
        this.cash = cash;
    }

    public Bag(Credit credit) {
        this.credit = credit;
    }

    public Bag(Credit credit, Cash cash) {
        this.credit = credit;
        this.cash = cash;
    }

    public boolean hasCash() {
        return cash != null;
    }

    public int getCash() {
        return cash.getCashAmount();
    }

    public int getCredit() {
        return credit.getCreditAmount();
    }
}

 

그리고 이 가방을 들고 있는 손님 Guest 클래스이다.

public class Guest {
    private Bag bag;

    public Guest(Bag bag) {
        this.bag = bag;
    }

    public Bag getBag() {
        return bag;
    }
}

 

마지막으로 가격을 요구하는 스태프 Staff 클래스를 만들어준다.

public class Staff {
    private Guest guest;

    public Staff(Guest guest) {
        this.guest = guest;
    }

    public int requestPayment() {
	int price;
        if(guest.getBag().hasCash()) {
            price = guest.getBag().getCash();
        } else{
            price = guest.getBag().getCredit();
        }
        return price;
    }
}

 

지금까지 작성한 클래스간 의존성은 아래와 같다.

결과도 제대로 나오기 때문에 언뜻보면 "잘 짠 코드 아닌가?" 라고 생각할 수 있다.

 

그러나 문제가 있다.

스태프가 손님의 가방에서 현금이 있는지 없는지 직접 확인하고 있기 때문이다.

즉, 객체 사이의 의존성이 강해 결합도가 높아진 것이다.

 

두 객체 사이의 결합도가 높으면 높을수록 함께 변경될 확률도 높아지기 때문에 변경하기 어려워진다.

 

자율성 부여

그래서 위에서 언급한 자율성을 부여해보도록 하자.

스태프는 결제를 요구한다는 요청만 손님에게 보내고, 손님이 직접 가방을 처리하도록 두는 것이다.

 

Staff 클래스에 있던 requestPayment를 전부 Guest 클래스로 옮기면 된다.

public class Guest {
    private Bag bag;

    public Guest(Bag bag) {
        this.bag = bag;
    }

//    public Bag getBag() {
//        return bag;
//    }

    public int requestGuest() {
        int price;
        if(bag.hasCash()) {
            price = bag.getCash();
        } else{
            price = bag.getCredit();
        }
        return price;
    }
}

public class Staff {
    private Guest guest;

    public Staff(Guest guest) {
        this.guest = guest;
    }

    public int requestPayment() {
      return guest.requestGuest();
    }
}

 

그러면 위 코드에서 볼 수 있듯이 geBag() 함수는 사용하지 않으므로 지워줘도 된다.

이제 스태프는 더이상 손님의 가방에 접근하지 못한다.

 

수정된 의존성은 다음과 같다.

Staff는 오직 Guest의 인터페이스(interface)에만 의존하고 있다.

객체를 인터페이스와 구현으로 나누고 인터페이스만을 공개하는 것은 객체 사이의 결합도를 낮추고 변경하기 쉬운 코드를 작성하기 위해 따라야 하는 가장 기본적인 설계 원칙이다.

 

더 개선하자

아직 개선해야 할 부분이 남아있다.

여전히 가방은 손님에 의해 끌려다니는 수동적인 존재이다.

그래서 Guest 클래스에 있던 "가방에 현금이 있는지 없는지" 확인하는 코드는 전부 Bag 클래스의 hold 함수를 새로 만들어 넣어준다.

public class Bag {
    private Cash cash;
    private Credit credit;

    public Bag(Cash cash) {
        this.cash = cash;
    }

    public Bag(Credit credit) {
        this.credit = credit;
    }

    public Bag(Credit credit, Cash cash) {
        this.credit = credit;
        this.cash = cash;
    }

    public int hold() {
        int price;
        if(hasCash()) {
            price = getCash();
        } else{
            price = getCredit();
        }
        return price;
    }

    private boolean hasCash() {
        return cash != null;
    }

    private int getCash() {
        return cash.getCashAmount();
    }

    private int getCredit() {
        return credit.getCreditAmount();
    }
}

public class Guest {
    private Bag bag;

    public Guest(Bag bag) {
        this.bag = bag;
    }

    public int buy() {
       return bag.hold();
    }
}

 

이제 Guest는 Bag의 구현이 아니라 인터페이스에 의존하게 되었다.

여기서 주목해봐야할 점은 기존 Bag 클래스의 public이었던 함수들이 모두 private이 되었다는 것이다.

캡슐화가 성공적으로 이루어진 것이다.

 

➡️ 이제 각 객체들은 책에서도 중요하게 언급하고 있는 본인의 역할에 책임을 다하고 있으며, 객체들간에도 협력을 하고 있다.