문제6

우아한테크코스에서는 교육생(이하 크루) 간 소통 시 닉네임을 사용합니다. 간혹 비슷한 닉네임을 정하는 경우가 있는데, 이러할 경우 소통할 때 혼란을 불러일으킬 수 있습니다.

혼란을 막기 위해 크루들의 닉네임 중 같은 글자가 연속적으로 포함 될 경우 해당 닉네임 사용을 제한하려 합니다. 이를 위해 같은 글자가 연속적으로 포함되는 닉네임을 신청한 크루들에게 알려주는 시스템을 만들려고 합니다.
신청받은 닉네임 중 같은 글자가 연속적으로 포함 되는 닉네임을 작성한 지원자의 이메일 목록을 return 하도록 solution 메서드를 완성해주세요.
제한사항

• 두 글자 이상의 문자가 연속적으로 순서에 맞추어 포함되어 있는 경우 중복으로 간주합니다.
• 크루는 1명 이상 10,000명 이하입니다.
• 이메일은 이메일 형식에 부합하며, 전체 길이는 11자 이상 20자 미만입니다.
• 신청할 수 있는 이메일은 email.com 도메인으로만 주어집니다.
• 닉네임은 한글만 가능하고 전체 길이는 1자 이상 20자 미만입니다.
• result는 이메일에 해당하는 부분의 문자열을 오름차순으로 정렬하고 중복은 제거합니다.

forms에는 5명의 크루가 신청서를 작성하였고 이 중 jason@email.com과 jm@email.com, mj@email.com 크루가 중복 닉네임 대상으로 뽑혔습니다. 따라서 이 세 크루의 이메일을 출력합니다.

풀이

package beautifultask;

import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class NickName {


    public static String[] solution(String[][] forms){

        String[] answer = new String[forms.length];

        HashSet<String> emails = new HashSet<>();

        final Map<String, String > hashMap = new HashMap<>();

        for (int i = 0; i < forms.length; i++) {

            final String name = forms[i][1];

            if(name.length() < 2){
                break;
            }


            for (int j = 0; j < name.length() - 1; j++) {
                final String key = name.substring(j, j+2);
                if(hashMap.containsKey(key)){
                    final String email = hashMap.get(key);
                    if(!email.equals(forms[i][0])){
                        emails.add(email);
                        emails.add(forms[i][0]);
                    }
                }
                hashMap.put(key, forms[i][0]);
            }
        }

        final List<String> collect = emails.stream()
                .sorted()
                .collect(Collectors.toList());
                   //List size가 인자로 넘어가는 배열 객체의 size 보다 클때, 해당 List의 size로 배열이 만들어집니다.
            //반대로 해당 List size가 인자로 넘어가는 배열객체의 size 보다 작을때는, 인자로 넘어가는 배열객체의 size로 배열이 만들어집니다.
        final String[] results = collect.toArray(new String[0]);

        return results;
    }

    public static void main(String[] args) {


        String[][] forms ={{"jm@email.com", "제이엠"},{"jason@email.com","제이슨"},{"woniee@email.com","워니"},{"mj@email.com","엠제이"},{"nowm@email.com","이제엠"}};


        String[] result = solution(forms);

        for (String value : result)
            System.out.println(value);


    }

}

우아한테스크코스 온라인 코딩 테스트 6번 문제입니다. 후반부 문제이지만 연속된 2자리 닉네임을 체크하는데 많은 고민을 하였습니다. 이 문제는 친구의 풀이를 보고 참조하였습니다.
결국 중복된 2글자가 겹치는 닉네임이 있으면 그 닉네임에 해당되는 이메일들을 가지고 있는 정렬된 문자열 배열을 리턴하는 것이 핀트입니다.

forms라는 2차원 배열에 이메일, 닉네임이 각각 들어있습니다. 저같은 경우에 HashSet, HashMap 클래스를 이용하여 중복체크를 하였습니다.

for (int j = 0; j < name.length() - 1; j++) {
    final String key = name.substring(j, j+2);
    if(hashMap.containsKey(key)){
        final String email = hashMap.get(key);
        if(!email.equals(forms[i][0])){
            emails.add(email);
            emails.add(forms[i][0]);
        }
    }
    hashMap.put(key, forms[i][0]);
}

문제4

배달 앱을 이용하려면 유저는 로그인 → 장바구니에 음식 담기 → 주문 과 같은 순서를 거칩니다. 이를 위해 서버에서는 다음과 같은 일을 합니다.

1. 로그인: LOGIN 아이디 비밀번호

   • 이미 로그인했다면 거부한다.
   • 아이디와 비밀번호가 유효하면 로그인을 허용한다.
   • 아이디와 비밀번호가 유효하지 않으면(아이디가 없거나 비밀번호가 다른 경우) 로그인을 거부한다.

2. 장바구니에 음식 담기: ADD 음식아이디

   • 로그인한 유저라면 허용한다.
   • 로그인하지 않았으면 거부한다.

3. 주문하기: ORDER

   • 장바구니에 담은 음식이 있으면 허용한다. 주문 후에는 장바구니를 비운다.
   • 장바구니에 담은 음식이 없으면 거부한다.
     서버에 저장된 유저 정보 infos와 한 사람의 행동을 담은 배열 actions가 매개변수로 주어질 때, 각 행동이 허용되었으면 true, 거부되었으면 false를 담아 return 하도록 solution 메서드를 완성해주세요.

제한 사항

• infos의 길이는 1 이상 10 이하입니다.
• infos의 원소는 아이디 비밀번호 형태입니다.
• actions의 길이는 1 이상 100 이하입니다.
• actions의 원소는 다음 형태 중 하나입니다.
  • LOGIN 아이디 비밀번호
  • ADD 음식아이디
  • ORDER
• infos와 actions 배열에서 주어지는 아이디와 비밀번호는 영문 소문자로만 이루어져 있습니다.
• actions 배열에서 주어지는 음식아이디는 숫자로만 주어집니다.

풀이

package beautifultask;

import java.util.*;

public class DeliveryProcess {

    public static boolean[] solution(String[] infos, String[] actions) {

        boolean[] answer = new boolean[actions.length];
        Member member = null;

        Map<String, Member> accounts = new HashMap<>();

        // 서버에 저장된 사용자 정보를 해시 Map 객체로 관리합니다.
        // Key 값은 회원 아이디로 회원 객체를 관리합니다.
        for (int i = 0; i < infos.length; i++) {
            String[] memberInfo = infos[i].split(" ");
            accounts.put(memberInfo[0], new Member(memberInfo[0], memberInfo[1]));
        }

        for (int i = 0; i < actions.length; i++) {
            String[] request = actions[i].split(" ");

            switch (request[0]) {
                case "ADD":
                    if (member != null) {
                        member.addFood(request[1]);
                        answer[i] = true;
                    } else {
                        answer[i] = false;
                    }
                    break;

                case "LOGIN":
                    boolean loginResult = getLoginResult(request, member, accounts);
                    if(loginResult) {
                        member = accounts.get(request[1]);
                    }
                    answer[i] = loginResult;
                    break;

                case "ORDER":
                    if(member == null){
                        answer[i] = false;
                    }else{
                       if(member.getCart().size() == 0){
                           answer[i] = false;
                       }else {
                           member.clearCart();
                           answer[i] = true;
                       }
                    }
                    break;

                    default:
                        throw new IllegalStateException("IllegalArgumentException");
            }
        }
        return answer;
    }

    //memberInfo = member 정보가 있습니다.
    public static boolean getLoginResult(String[] request, Member member, Map<String, Member> accounts){

        if(!accounts.containsKey(request[1])){
            return false;
        }

        final Member accountMember = accounts.get(request[1]);

        if(!accountMember.getPassword().equals(request[2])){
            return false;
        }

        if(member != null){
            return false;
        }

        return true;
    }


    public static void main(String[] args) {

        String[] infos = {"kim password", "lee abc"};
        String[] actions = {
                "ADD 30",
                "LOGIN kim abc",
                "LOGIN lee password",
                "LOGIN kim password",
                "LOGIN kim password",
                "ADD 30",
                "ORDER",
                "ORDER",
                "ADD 40",
                "ADD 50"};

        boolean[] result = solution(infos, actions);

        for (boolean answer : result) {
            System.out.println(answer);
        }


    }

}


class Member {

    private String id;
    private String password;
    // HashSet 클래스는 중복을 거르고 담기 때문에 식별자가 유일한 개체만 담습니다.
    private HashSet<String> cart = new HashSet<>();


    public Member(String id, String password) {
        this.id = id;
        this.password = password;
    }


    public void addFood(String foodId) {
        cart.add(foodId);
    }

    public void clearCart() {
        cart.clear();
    }


    public HashSet<String> getCart() {
        return cart;
    }

    public String getPassword() {
        return password;
    }
}

우아한테스크코스 온라인 코딩 테스트 4번 문제는 배달앱 주문과정을 구현하는 것입니다.
위에 나와있는 룰에 기반하여 행동이 들어있는 문자열 타입의 배열을 받아서 허용할지 거부할지 판단하여 boolean 타입의 배열을 리턴하는 것이 핵심입니다.

가장 먼저, 서버에 저장된 회원의 아이디와 패스워드 정보가 들어있는 infos 배열을 각각의 HashMap 클래스를 사용하여 Member 객체의 생성자 로 넣어주어 관리하도록 하였습니다.

for (int i = 0; i < infos.length; i++) {
    String[] memberInfo = infos[i].split(" ");
    accounts.put(memberInfo[0], new Member(memberInfo[0], memberInfo[1]));
}

이 문제를 자세히 살펴보면 행동이 담긴 문자열 배열의 값이 ADD 데이터, LOGIN 데이터, ORDER 데이터 으로 구성되어 있는데 뒤에 나오는 데이터는 공백으로 구분되어 있습니다. 이것을 split() 메서드를 사용하여 공백으로 문자열을 자른 후에 각각의 행동을 처리하도록 swich문을 이용하여 해결하였습니다.

public static boolean getLoginResult(String[] request, Member member, Map<String, Member> accounts){

    if(!accounts.containsKey(request[1])){
        return false;
    }

    final Member accountMember = accounts.get(request[1]);

    if(!accountMember.getPassword().equals(request[2])){
        return false;
    }

    if(member != null){
        return false;
    }

    return true;
}

위의코드는 행동이 LOGIN일때 처리하는 부분입니다.
이미 로그인한 회원이 있으면 false, Map 객체에 containsKey() 메서드로 아이디가 존재하는지 확인하고 없으면 마찬가지로 false, 아이디가 존재하지만 패스워드가 틀리면 false를 리턴하도록 작성하였습니다. 이 세가지 조건을 다 충족하지 않는다면 로그인한 유저가 없거나 아이디, 패스워드가 서버에 저장된 정보랑 일치하는걸로 판단하여 true를 리턴합니다.

그리고 member 객체는 로그인 정보가 들어있는 행동 배열 값이랑 일치하기 때문에 로그인하도록 처리하였습니다.

문제 설명

접속자가 많을 때는 서버를 많이, 접속자가 적을 때에는 서버를 적게 띄워야 합니다. 배달의 민족에서는 각 시간대에 발생한 로그 수를 파악해 미래에 서버를 몇 대 띄울지 계산하려 합니다. 로그는 YYYY/MM/DD hh:mm:ss 형식으로 표시되며, 한국은 UTC+09:00 시간대이므로 로그에 표시된 시각에서 9시를 더해야 올바른 한국 시각이 나옵니다.

예를 들어 2019/10/01 09:33:19 로그는 한국 기준, 2019년 10월 1일 18시 33분 19초에 발생한 로그입니다.
로그 발생 시각을 담은 문자열 logs가 매개변수로 주어졌을 때 0시부터 23시까지, 한국 시간 기준 각 시간대별로 로그가 몇 회씩 발생했는지 return 하도록 메서드를 완성해주세요.

제한 사항

• 발생 시각은 개행(\n) 문자로 구분되어있습니다.
• 발생 시각은 10개 이상 100개 이하로 주어집니다.
• 발생 시각은 YYYY/MM/DD hh:mm:ss 형식이며 24시 표시법을 따릅니다.
• 연도는 2011 이상 2019 이하 값으로만 주어집니다.
• 잘못된 시각이 주어지는 경우(-1년 13월 55일 25시 82분 400초 등)는 없습니다.

풀이

package beautifultask;

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.Arrays;

public class PrintLogNumber {

    public static int[] solution(String[] input) {

        int[] hours = new int[24];
        Arrays.fill(hours, 0);

        DateTimeFormatter pattern = DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss");

        for (int i = 0; i < input.length; i++) {

            final LocalDateTime parser = LocalDateTime.parse(input[i], pattern);

            // 시간 정보만 가져옵니다.
            int hour = parser.getHour() + 9;
            hours[hour] += 1;
        }

        return hours;
    }


    public static void main(String[] args) {

        String log = "2019/05/01 00:59:19\n" +
                "2019/06/01 01:35:20\n" +
                "2019/08/01 02:01:22\n" +
                "2019/08/01 02:01:23\n" +
                "2019/08/02 03:02:35\n" +
                "2019/10/03 04:05:40\n" +
                "2019/10/04 06:23:10\n" +
                "2019/10/10 08:23:20\n" +
                "2019/10/12 08:42:24\n" +
                "2019/10/23 08:43:26\n" +
                "2019/11/14 08:43:29\n" +
                "2019/11/01 10:19:02\n" +
                "2019/12/01 11:23:10\n";

        String[] input = log.split("\n");

        int[] result = solution(input);

        for (int value : result) {
            System.out.println(value);
        }

    }
}

어제 우아한테스크코스 온라인 코딩 테스트에서 나온 2번 문제입니다. 한국 시간 기준 각 시간대별로 로그가 몇 회씩 발생했는지 배열 타입으로 return 하는 것이 핀트입니다.

이 문제를 분석하면서 출제자의 의도를 분석을 해보면서 해당 날짜 관련 데이터에서 얼마나 잘 핸들링 할 수 있는지 파악하는것이 목적이 아닐까.. 조심스럽게 생각해봤습니다.
평상시에 날짜, 시간과 관련된 객체를 다루어 본 경험이 있으시다면 그렇게 어렵지 않는 문제였습니다.

먼저, 문자열 변수에 들어있는 날짜 데이터들을 \n을 구분자로 문자열 타입 배열로 변환해주고 처리하는게 가장 처리하기 쉬운거 같습니다.

두번째로는 아래와 같이 java.time.format 패키지에서 제공해주는 DateTimeFormatter 클래스를 사용하여 ofPattern 메서드로 출력형식으로 원하는 날짜 포맷을 지정해줍니다.

DateTimeFormatter pattern = DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss"); 

주의사항: yyyy/MM 은 대소문자 구분 없이 연,월을 표현하지만, dd,HH,ss는 대소문자에 따라 출력형식이 달라집니다.
DD는 년의 몇 번째 일(1 ~366), dd는 월의 몇 번째 일(1~31), HH는 시간(0~23), hh 시간(1~12), SS(1/1000초) ss는 초(0~59)를 의미합니다.

마지막으로 자바 1.8부터 제공해주는 날짜와 관련된 클래스인 LocalDateTime 객체의 parse() 메서드를 사용하여 날짜 데이터가 들어있는 문자열 타입의 배열을 꺼내와서 이전에 DateTimeFormatter으로 지정한 출력형식으로 파싱을 하여 LocalDateTime 객체를 얻어옵니다.

LocalDateTime parser = LocalDateTime.parse(input[i], pattern);

이제 날짜, 시간 등 원하는 대로 처리 할 수 있습니다.

아래는 자바 1.8 버전부터 제공해주는 날짜 관련 객체와 메소드에 대한 정보가 나와있는 참조 사이트입니다. 아래 개발자분들이 올려주신 정보는 저에게 정말 많은 도움이 되었습니다.

참조: https://lovefields.github.io/java/2017/06/15/post76.html, https://jekalmin.tistory.com/entry/%EC%9E%90%EB%B0%94-18-%EB%82%A0%EC%A7%9C-%EC%A0%95%EB%A6%AC

문제 설명

문자열로 구성된 리스트 strings와, 정수 n이 주어졌을 때, 각 문자열의 인덱스 n번째 글자를 기준으로 오름차순 정렬하려 합니다. 예를 들어 strings가 [sun, bed, car]이고 n이 1이면 각 단어의 인덱스 1의 문자 u, e, a로 strings를 정렬합니다.

제한 조건

1. strings는 길이 1 이상, 50이하인 배열입니다.
2. strings의 원소는 소문자 알파벳으로 이루어져 있습니다.
3. strings의 원소는 길이 1 이상, 100이하인 문자열입니다.
4. 모든 strings의 원소의 길이는 n보다 큽니다.
5. 인덱스 1의 문자가 같은 문자열이 여럿 일 경우, 사전순으로 앞선 문자열이 앞쪽에 위치합니다.

입출력 예 설명

입출력 예 1

sun, bed, car의 1번째 인덱스 값은 각각 u, e, a 입니다. 이를 기준으로 strings를 정렬하면 [car, bed, sun] 입니다.

입출력 예 2

abce와 abcd, cdx의 2번째 인덱스 값은 c, c, x입니다. 따라서 정렬 후에는 cdx가 가장 뒤에 위치합니다. abce와 abcd는 사전순으로 정렬하면 abcd가 우선하므로, 답은 [abcd, abce, cdx] 입니다.

package jungja_study;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class StringSorting {

    public static String[] solution(String[] words, int n) {

        int length = words.length;
        String[] alpa = new String[length];
        String[] answer = new String[length];
        List<String> list = new ArrayList<>();

        // words 배열의 n번째 인덱스에 해당하는 문자를 alpa 배열에 대입
        for (int i = 0; i < words.length; i++) {
            alpa[i] = String.valueOf(words[i].charAt(n));
        }
        // words 배열 각각의 요소의 n번째 인덱스의 문자가 같은 경우에 사전순으로 앞선 문자열로 정렬해야합니다.
        // 따라서 미리 정렬을 통해서 나중에 정렬된 alpa 배열과 비교하여 찾을때 따로 사전순으로 앞선 정렬 처리를 할 필요가 없어집니다.
        Arrays.sort(words);
        //words 배열의 n번째 인덱스에 해당하는 문자를
        Arrays.sort(alpa);


        //정렬된 alpa 배열과 words 배열을 비교하여 words서 배열 정수 n 값에 따라 컬렉션타입의 리스트 객체에 저장합니다.
        for (int i = 0; i < alpa.length; i++) {
            for (int j = 0; j < words.length; j++) {
                if(alpa[i].equals(String.valueOf(words[j].charAt(n)))){
                    if (!list.contains(words[j])) {
                        list.add(words[j]);
                    }
                }
            }
        }


        answer = list.toArray(new String[list.size()]);

        return answer;
    }

    public static void main(String[] args) {

        String[] testCase1 = {"sun", "bed", "car"};
        String[] testCase2 = {"abce", "abcd", "cdx"};

        String[] result1 = solution(testCase1, 1);
        String[] result2 = solution(testCase2, 2);


        for (String s : result1) {
            System.out.println(s);
        }

        for (String s : result2) {
            System.out.println(s);
        }
    }
}

이 문제는 문자열 처리 능력을 묻는 문제로 chartAt와 String.valueOf, Arrays.sort 메소드를 활용하여 풀었습니다. 난이도는 그렇게 어려운 편은 아니였지만 아무래도 제 수준에서 그나마 까다로웠던 조건이 인덱스 1의 문자가 같은 문자열일 여럿 일 경우, 사전순으로 앞선 문자열이 앞쪽에 위치해야하는 조건에서 좀 생각을 깊게 했었던거 같습니다.

이 부분은 단순하게 미리 Arrays.sort()로 주어진 배열을 사전순으로 정렬한 후에 n번째 인덱스에 해당하는 문자만 들어있는 배열 alpa와 비교를 통해 같은 것만 컬렉션 타입의 객체에 넣어주면 되는 문제입니다.

문제 설명

전화번호부에 적힌 전화번호 중, 한 번호가 다른 번호의 접두어인 경우가 있는지 확인하려 합니다.

전화번호가 다음과 같을 경우, 구조대 전화번호는 영석이의 전화번호의 접두사입니다.

구조대 : 119
박준영 : 97 674 223
지영석 : 11 9552 4421

전화번호부에 적힌 전화번호를 담은 배열 phone_book 이 solution 함수의 매개변수로 주어질 때, 어떤 번호가 다른 번호의 접두어인 경우가 있으면 false를 그렇지 않으면 true를 return 하도록 solution 함수를 작성해주세요.

제한 사항

1. phone_book의 길이는 1 이상 1,000,000 이하입니다.
2. 각 전화번호의 길이는 1 이상 20 이하입니다.

입출력 예 설명

입출력 예 #1
앞에서 설명한 예와 같습니다.

입출력 예 #2
한 번호가 다른 번호의 접두사인 경우가 없으므로, 답은 true입니다.

입출력 예 #3
첫 번째 전화번호, “12”가 두 번째 전화번호 “123”의 접두사입니다. 따라서 답은 false입니다.

package jungja_study;

import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

public class PhoneNumberList {

    public boolean solutionh(String[] phone_book) {

        boolean answer = true;
        Map<Integer, String> map = new HashMap<>();

        Arrays.sort(phone_book);

        for (int i = 0; i < phone_book.length; i++) {
            map.put(i, phone_book[i]);
        }

        for (int i = 0; i < phone_book.length; i++) {
            System.out.println(map.get(i));
        }


        for (int i = 0; i < map.size() - 1; i++) {
            if (map.get(i).length() < map.get(i + 1).length()) {
                if (map.get(i + 1).startsWith(map.get(i))) {
                    answer = false;
                    break;
                }
            }
        }

        return answer;
    }


    public static void main(String[] args) {

        PhoneNumberList phoneNumberList = new PhoneNumberList();
        String[] phone_book = {"119", "97674223", "1195524421"};
        String[] phone_book2 = {"123", "456", "789"};
        String[] phone_book3 = {"12", "123", "1235", "567", "88"};
        System.out.println(phoneNumberList.solutionh(phone_book));
        System.out.println(phoneNumberList.solutionh(phone_book2));
        System.out.println(phoneNumberList.solutionh(phone_book3));

    }
}

사실 해시 관련 문제이기 대문에 해시로 엮어서 풀려고 많은 생각을 했지만... 테스트 케이스 7,8에서 계속 에러가 발생하여서.. 다른 풀이의 답을 참조하게 되었습니다. 하지만 대부분 풀이를 보면 해시를 사용하기 보다는 정렬을 이용해서 문자열 메소드 startWith를 이용하여 푸는게 가장 깔끔하게 풀어집니다. 이 문제의 핵심은 전화번호가 들어가 있는 phone_number 배열에서 각각의 전화번호가 다른 인덱스에 있는 전화번호의 접두사인지 확인하여 false, true 둘 중에 하나를 리턴하면 되는 문제입니다.

저 같은 경우에는 HashMap 객체를 이용하여 전화번호 목록에 있는 번호들을 넣었지만, 사실 여기서 가장 핵심은 Arrays.sort() 정렬 메소드 입니다. 굳이 해시를 이용하지 않아도 간단하게.. 풀리는 문제였습니다.
sort() 메소드로 전화번호 목록이 담긴 배열을 넣으면 사전식으로 정렬이 되기 때문에 어떤 전화번호의 접두사가 되는 전화번호가 앞 순서에 위치하게 되기 때문에 정렬된 전화번호 리스트를 순회하여 다음에 오는 전화번호가 현재 전화번호로 시작하는지 체크를 해주면 됩니다.

프로그래머스에서 Best Practice를 보면 정렬없이 아래와 같이 풀수도 있습니다.

for(int i=0; i<phone_book.length-1; i++) {
    for(int j=i+1; j<phone_book.length; j++) {
        if(phone_book[i].startsWith(phone_book[j])) {return false;}
        if(phone_book[j].startsWith(phone_book[i])) {return false;}

    }
}

위와 같은 방식으로 풀면 문자열 길이를 체크하지 않고 순회하며 비교가 가능합니다.

2019년에 조영호님께서 출판한 OBJECTS 코드로 이해하는 객체지향 설계라는 책을 사놓고... 읽지를 않다가 조금씩이라도 읽으면서 나중에 잊어버리지 않도록 하기 위해서 간단하게 1장 객체, 설계에 대해서 블로그에 포스팅을 해보았습니다.

패러다임의 시대

가장 먼저 소개하고 있는 부분이 패러다임의 대한 것입니다. 제가 생각하는 패러다임은 한 시대의 사회 전체가 공유하는 이론이나 방법, 문제 의식 등의 체계 정도로만 알고 있었는데 이 책에서는 패러다임이 어떻게 등장하였고 프로그래밍 세계에서 패러다임이 의미하는것이 무엇인지 구체적으로 설명하고 있습니다.

과거에는 표준적인 모델을 따르거나 모방하는 상황을 가르키는 매우 제한적인 상황에서만 패러다임이라는 단어를 사용했습니다.
쿤이라는 사람은 과학혁명의 구조라는 책을 세상에 내놓았는데, 이 책에는 기존의 과학사에 대한 관점을 뿌리채 흔들었습니다.
과학혁명은 과학이 단순한 계단식 발전의 형태를 이루는 것이 아니라 새로운 발견이 기존의 과학적 견해를 붕괴시키는 혁명정인 과정을 거쳐 발전해왔다고 주장했습니다.
과학혁명이란 과거의 패러다임이 새로운 패러다임에 의해 대체됨으로써 정상과학의 방향과 성격이 변하는 것을 의미합니다. 이를 패러다임(Paradigm Shift)의 전환이라고 부릅니다. 대표적인 예로는 우주를 바라보는 관점이 천동설에서 지동설로 변화한 사건이 있습니다.

이제 프로그래밍 관점에서 패러다임을 살펴보겠습니다.
프로그래밍 패러다임은 특정 시대의 어느 성숙한 개발자 공동체에 의해 수용된 프로그래밍 방법과 문제 해결 방법, 프로그래밍 스타일이라고 할 수 있습니다. 간단히 말해서 우리가 어떤 프로그래밍 패러다임을 사용하느냐에 따라 우리가 해결할 문제를 바라보는 방식과 프로그램을 작성하는 방법이 달라집니다.
프로그래밍 패러다임은 개발자 공동체가 동일한 프로그래밍 스타일과 모델을 공유할 수 있게 함으로써 불필욜한 부분에 대한 의견 충돌을 방지합니다. 또한 프로그래밍 패러다임을 교욱시킴으로써 동일한 규칙과 방법을 공유하는 개발자로 성장할 수 있도록 준비시킬 수 있습니다.

결국 이 책은 객체지향 패러다임에 관한 책으로써 객체지향 패러다임이 제시하는 프로그래밍 패러다임을 설명하는 것에 목적을 두고 있습니다. 또한 객체지향에 대한 다양한 오해를 제거함으로써 객체지향 프로그래밍을 하는 개발자들이 동일한 규칙과 표준에 따라 프로그램을 작성할 수 있게 할 것입니다.

티켓 판매 애플리케이션 구현하기

이 책은 이론보다 실무를 강조하는 책입니다. 그렇기 때문에 객체지향에 대한 다양한 측면을 설명하기 위해 이론보다는 코드를 작성하여 설명할 것입니다.

이번 시간에는 간단한 티켓 판매 프로그램을 작성하여 리뷰해보겠습니다.

이 프로그램은 관객이 티켓을 통해 소극장에 입장하여 연극이나 음악회를 즐길 수 있습니다. 여기에 소극장을 홍보도 겸할 겸 관람객들의 발길이 이어지도록 작은 이벤트를 기획하기로 했습니다. 이벤트의 내용은 간단하게 추첨을 통해 선정된 관람객에게 공연을 무료로 관람할 수 있는 초대장을 발송하는 것입니다.

여기서 핀트는 이벤트에 당첨된 관람객과 그렇지 못한 관램객은 다른 방식으로 극장에 입장시켜야 한다는 것입니다. 이벤트에 당첨된 관람객은 초대장을 티켓으로 교환한 후에 입장할 수 있습니다.
이벤트에 담청되지 않은 관람객은 티켓을 구매해야만 입장할 수 있습니다. 따라서 관람객을 입장시키기 전에 이벤트 당첨 여부를 확인해야 하고 이벤트 당첨자가 아닌 경우에는 티켓을 판매한 후에 입장시켜야 합니다.

먼저, 이벤트 당첨자에게 발송하는 초대장을 구현하는 것으로 시작하겠습니다.
초대장이라는 개념을 구현한 Invitation은 공연을 관람할 수 있는 초대일자를 인스턴스 변수로 포함하는 간단한 클래스입니다.

package object;

import java.time.LocalDateTime;

public class Invitation {

    private LocalDateTime when;
}

공연을 관람하기 원하는 모든 사람들은 티켓을 소지하고 있어야만 하기 때문에 Ticket 클래스도 추가합니다.

package object;

public class Ticket {

    private Long fee;

    public Long getFee(){
        return this.fee;
    }
}

이벤트 당첨자는 티켓으로 교환할 초대장을 가지고 있습니다. 이벤트에 당첨되지 않은 관람객은 티켓을 구매할 수 있는 현금을 보유하고 있을 것입니다. 따라서 관람객이 가지고 올 수 있는 소지품은 초대장, 현금, 티켓 세 가지뿐 입니다.

이제 관람객이 소지품을 보관할 Bag 클래스를 추가해봅니다. Bag 클래스는 초대장(invitation), 티켓(ticket), 현금(amount)을 인스턴스 변수로 포함합니다.
또한 초대장의 보유 여부를 판단하는 hasInvitation 메서드와 티켓의 소유 여부를 판단하는 hasTicket 메서드, 현금을 증가시키거나 감소시키는 plusAmount, minusAmount 메서드, 초대장을 티켓을오 교환하는 setTicket 메서드를 구현하고 있습니다.

package object;

public class Bag {

    private Long amount;
    private Ticket ticket;
    private Invitation invitation;

    // 이벤트 당첨자가 아닐 경우 초대장이 없고 현금만 보유하고 있기 때문에 생성자로 아래 this 키워드를 이용하여 초대장에 null값을 참조
    public Bag(Long amount){
        this(null, amount);
    }

    // 이벤트 당첨자일 경우 초대장과, 현금을 둘다 보유하고 있기 때문에 아래와 같은 생성자를 호출합니다.
    public Bag(Invitation invitation, Long amount){
        this.invitation = invitation;
        this.amount = amount;
    }

    // 초대장이 있습니까?
    public boolean hasInvitation(){
        return this.invitation != null;
    }

    // 티켓이 있습니까?
    public boolean hasTicket(){
        return this.ticket != null;
    }
    // 현금 감소
    public void minusAmount(Long amount){
        this.amount -= amount;
    }
    // 현금 증가
    public void plusAmount(Long amount){
        this.amount += amount;
    }
    //티켓 교환
    public void setTicket(Ticket ticket){
            this.ticket = ticket;
    }

}

여기서 이벤트에 당첨된 관람객의 가방 안에는 현금과 초대장이 들어있지만 이벤트에 당첨되지 않는 관람객의 경우 가방 안에는 초대장이 들어있지 않을 것입니다. Bag 인스턴스의 상태는 현금과 초대장을 함꼐 보관하거나, 초대장 없이 현금만 보관하는 두 가지 중 하나일 것 입니다.
위의 코드에서 Bag 인스턴스를 생성하는 시점에 이 제약을 강제할 수 있도록 생성자를 추가하였습니다.

다음은 관람객이라는 개념을 구현하는 Audience 클래스를 정의하였습니다. 관람객은 소지품을 보관하기 위해 가방을 소지할 수 있습니다.

package object;

public class Audience {

    private Bag bag;

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

    public Bag getBag() {
        return bag;
    }
}

관람객이 소극장에 입장하기 위해서는 매표소에서 초대장을 티켓으로 교환하거나 구매해야 합니다. 따라서 매표소에는 관람객에게 판매할 티켓과 티켓의 판매 금액이 보관되어야 합니다. 매표소를 구현하기 위해 TicketOffice 클래스를 구현할 것 입니다.
TicketOffice는 판매하거나 교환해 줄 티켓의 목록(tickets)과 판매금액(amount)을 인스턴스 변수로 포함합니다. 티켓을 판매하는 getTicket 메서드는 편의를 위해 tickets 컬렉션에서 맨 첫번째 위치에 저장된 Ticket을 반환하는 것으로 구현했습니다. 또는 판매금액을 더하거나 차감하는 plusAmount와 minusAmount 메서드로 구현돼 있습니다.

package object;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class TicketOffice {

    private Long amount;
    private List<Ticket> tickets = new ArrayList<>();

    public TicketOffice(Long amount , Ticket ... tickets){
        this.amount = amount;
        this.tickets.addAll(Arrays.asList(tickets));
    }


    public Ticket getTicket(){
        return this.tickets.remove(0);
    }

    public void minusAmount(Long amount){
        this.amount -= amount;
    }

    public void plusAmount(Long amount){
        this.amount += amount;
    }

}

판매원은 매표소에서 초대장을 티켓으로 교환해 주거나 티켓을 판매하는 역할을 수행합니다. 판매원을 구현한 TicketSeller 클래스는 자신이 일하는 매표소(ticketOffice)를 알고 있어야 합니다.

package object;

public class TicketSeller {

    private TicketOffice ticketOffice;

    public TicketSeller(TicketOffice ticketOffice) {
        this.ticketOffice = ticketOffice;
    }

    public TicketOffice getTicketOffice() {
        return ticketOffice;
    }
}

모든 준비가 끝이 났습니다. 이제 아래의 그림처럼 클래스들을 조합해서 관람객을 소극장에 입장시키는 로직을 완성하는 일만 남았습니다.

소극장을 구현하는 클래스 Theater입니다. Theater 클래스가 관람객을 맞이할 수 있도록 enter 메소드를 구현합시다.

package object;

public class Theater {

    private TicketSeller ticketSeller;

    public Theater(TicketSeller ticketSeller) {
        this.ticketSeller = ticketSeller;
    }


    public void enter(Audience audience){

        if(audience.getBag().hasInvitation()){
            Ticket ticket = ticketSeller.getTicketOffice().getTicket();
            audience.getBag().setTicket(ticket);
        }else {

            Ticket ticket = ticketSeller.getTicketOffice().getTicket();
            audience.getBag().minusAmount(ticket.getFee());
            ticketSeller.getTicketOffice().plusAmount(ticket.getFee());
            audience.getBag().setTicket(ticket);

        }
    }
}

소극장은 먼저 관람객의 가방 안에 초대장이 들어 있는지 확인합니다. 만약 초대장이 들어 있다면 이벤트에 당첨된 관람객이므로 판매원에게 받은 티켓을 관람객의 가방 안에 넣어줍니다. 가방 안에 초대장이 없다면 티켓을 판매해야 합니다. 이 경우 소극장은 관람객의 가방에서 티켓 금액만큼을 차감한 후 메표소에 금액을 증가시킵니다. 마지막으로 소극장은 관람객의 가방 안에 티켓을 넣어줌으로써 관람객의 입장 절차를 끝냅니다.

여기까지만 작성해도 프로그램 로직은 간단하고 예상했던대로 동작합니다. 하지만 안타깝게도 이 작은 프로그램은 몇가지 문제점을 가지고 있습니다.

무엇이 문제인가

로버트 마틴은 <클린 소프트웨어: 애자일 원칙과 패턴, 그리고 실천 방법>에서 소프트웨어 모듈이 가져야 하는 세 가지 기능에 관해 설명합니다. 여기서 모듈이란 크기와 상관없이 클래스나 패키지, 라이브러리와 같이 프로그램을 구성하는 임의의 요소를 의미합니다.

모든 소프트웨어 모듈에는 세가지 목적이 있습니다.

• 첫 번째 목적은 실행 중에 제대로 동작하는 것입니다. 이것은 모듈의 존재 이유입니다.

• 두 번째 목적은 변경을 위해 존재하는 것입니다. 대부분의 모듈은 생명주기 동안에 변경되기 때문에 간단한 작업만으로도 변경이 가능해야합니다. 변경하기 어려운 모듈은 제대로 동작하더라도 개선해야 합니다.

• 세 번째 목적은 코드를 읽는 사람과 의사소통 하는 것입니다. 모듈은 특별한 훈련 없이도 개발자가 쉽게 읽고 이해할 수 있어야 합니다. 읽는 사람과 의사소통 할 수 없는 모듈은 개선해야 합니다.

위에서 작성한 티켓 판매 프로그램은 관람객들을 입장시키는데 필요한 기능을 오류 없이 정확하게 수행하고 있습니다. 따라서 제대로 동작해야 한다는 제약은 만족합니다. 하지만 불행하게도 변경 용이성과 읽는 사람과의 의사소통이라는 목적은 만족시키지 못합니다.

예상을 빗나가는 코드

마지막에 소개한 Theater 클래스의 enter 메소드가 수행하는 일을 풀어보겠습니다.

소극장은 관람객의 가방을 열어 그 안에 초대장이 들어 있는지 살펴봅니다. 가방 안에 초대장이 들어 있으면 판매원은 매표소에 보관돼 있는 티켓을 관람객의 가방 안으로 옮깁니다. 가방 안에 초대장이 들어 있지 않다면 관람객의 가방에서 티켓 금액만큼의 현금을 꺼내 매표소에 적립한 후에 매표소에 보관돼 있는 티켓을 관람객의 가방 안으로 옮깁니다.

여기서 문제는 관람객과 판매원이 소극장의 통제를 받는 수동적인 존재라는 점입니다.
관람객의 입장에서 문제는 소극장이라는 제3자가 초대장을 확인하기 위해 관람객의 가방을 마음대로 열어 본다는데 있습니다. 만약 누군가가 허락 없이 가방 안의 내용물을 마음대로 뒤적이고 돈을 가져간다면... 어떻겠습니까.. 넋놓고 다른 사람이 저의 가방을 헤집어 넣는 것을 멍하니 바라볼 사람은 없을 것입니다.

판매원도 마찬가지 입니다. 소극장이 판매원의 허락도 없이 매표소에 보관 중인 티켓과 현금을 마음대로 접근 할 수 있기 때문입니다. 더 큰 문제는 티켓을 꺼내 관람객의 가방에 집어넣고 관람객에게서 받은 돈을 매표소에 적립하는 일을 판매원이 아닌 소극장이 수행한다는 점입니다. 판매원 입장에서는 가만히 앉아 티켓이 하나씩 사라지고 돈이 저절로 쌓이는 광경을 두 손 놓고 쳐다볼 수 밖에 없는 것입니다.

현재 위의 코드는 우리의 상식과는 다르게 너무나도 다르게 동작하기 때문에 코드를 읽는 사람과 제대로 의사소통하지 못합니다.
코드를 이해하기 어렵게 만드는 또 다른 이유는 이 코드를 이해하기 위해서는 여러가지 세부적인 내용들을 한꺼번에 기억하고 있어야 합니다. Theater의 enter 메소드를 살펴보면 Audience가 Bag을 가지고 있고, Bag 안에는 현금과 티켓이 들어 있으며 TicketSeller가 TicketOffice에서 티켓을 판매하고, TicketOffice안에 돈과 티켓이 보관돼 있다는 모든 사실을 동시에 기억하고 있어야 합니다. 이 코드는 하나의 클래스나 메서드에 너무 많은 세부사항을 다뤽 때문에 코드를 작성하는 사람뿐만 아니라 코드를 읽고 이해해야 하는 모두에게 큰 부담을 줍니다.

하지만 가장 심각한 문제는 이것이 아닙니다. 그것은 Audience와 TicketSeller를 변경할 경우 Theater도 함께 변경해야 한다는 사실입니다.

변경에 취약한 코드

더 큰 문제는 변경에 취약하다는 것입니다. 이 코드는 관람객이 현금과 초대장을 보관하기 위해 항상 가방을 들고 다닌다고 가정합니다. 또한 판매원이 매표소에서만 티켓을 판매한다고 가정합니다. 관람객이 가방을 들고 있지 않다면 어떻게 해야할까요?
관람객이 현금이 아니라 신용카드를 이용해서 결제를 한다면 어떻게 해야할까요? 판매원이 매표소 밖에서 티켓을 판매해야 한다면 어떻게 해야할까요? 이런 가정이 깨지는 순간 모든 코드가 일시에 흔들리게 됩니다.

관람객이 가방을 들고 있다는 가정이 바뀌었다고 상상해봅시다. Audience 클래스에서 Bag을 제거해야 할뿐만 아니라 Audience의 Bag에 직접 접근하는 Theater의 enter 메소드 역시 수정해야 합니다. Theater는 관람객이 가방을 들고 있고 판매원이 매표소에서만 티켓을 판매한다는 지나치게 세부적인 사실에 의존해서 동작합니다. 이러한 세부적인 사실 중 한 가지라도 바뀌면 해당 클래스 뿐만 아니라 이 클래스에 의존하는 Theater도 함께 변경해야 합니다. 이처럼 다른 클래스가 Audience의 내부에 대해 더 많이 알면 알수록 Audience를 변경하기 어려워집니다.

이것은 객체 사이의 의존성(dependency)과 관련된 문제입니다. 문제는 의존성이 변경과 관련돼 있다는 점입니다. 의존성은 변경에 대한 영향을 암시합니다. 의존성이라는 말 속에는 어떤 객체가 변경될 때 그 객체에게 의존하는 다른 객체도 함꼐 변경될 수 있다는 사실이 내포돼 있습니다.

그렇다고 해서 객체 사이의 의존성을 완전히 없애는 것이 정답이 아닙니다. 객체지향 설계는 서로 의존하면서 협력하는 객체들의 공동체를 구축하는 것입니다. 따라서 우리의 목표는 애플리케이션의 기능을 구현하는데 필요한 최소한의 의존성만 유지하고 불필요한 의존성을 제거하는 것입니다.

객체 사이의 의존성이 과한 경우를 가리켜 결합도(coupling)가 높다고 말합니다. 반대로 객체들이 합리적인 수준으로 의존할 경우에는 결합도가 낮다고 말합니다. 결합도는 의존성과 관련돼 있기 때문에 결합도 역시 변경과 관련이 있습니다. 두 객체 사이의 결합도가 높으면 높을수록 함께 변경될 확률도 높아지기 때문에 변경하기 어려워 집니다. 따라서 설계의 목표는 객체 사이의 결합도를 낮춰 변경이 용이한 설계를 만드는 것입니다.

설계 개선하기

예제 코드는 로버트 마틴이 이야기한 세 가지 목적 중 한가지는 만족시키지만 다른 두 조건은 만족시키지 못합니다. 이 코드는 기능은 제대로 수행하지만 이해하기 어렵고 변경하기 쉽지 않습니다.

여기서 변경과 의사소통이라는 문제가 서로 엮여 있다는 점에 주목합니다. 코드를 이해하기 어려운 이유는 Theater가 관람객의 가방과 판매원의 매표소에 직접 접근하기 때문입니다. 이것은 관람객과 판매원이 자신의 일을 스스로 처리해야 한다는 우리의 직관을 벗어납니다. 다시 말해서 의도를 정확하게 의사소통하지 못하기 때문에 코드가 이해하기 어려워진 것입니다. Theater가 관람객의 가방과 판매원의 매표소에 직접 접근한다는 것은 Theater가 Audience와 TicketSeller에 결합된다는 것을 의미합니다. 따라서 Audience와 TicketSeller를 변경할 때 Theater도 함꼐 변경해야 하기 때문에 전체적으로 코드를 변경하기도 어려워집니다.

해결방법은 간단합니다. Theater가 Audience와 TicketSeller에 관해 너무 세부적인 부분까지 알지 못하도록 정보를 차단하면 됩니다. 사실 관람객이 가방을 가지고 있다는 사실과 판매원이 매표소에서 티켓을 판매한다는 사실을 Theater가 알아야 할 필요가 없습니다. Theater가 원하는 것은 관람객이 소극장에 입장하는 것 뿐입니다. 따라서 관람객이 스스로 가방 안의 현금과 초대장을 처리하고 판매원이 스스로 매표소의 티켓과 판매 요금을 다루게 한다면 이 모든 문제를 한 번에 해결할 수 있습니다.

다시 말해서 관람객과 판매원을 자율적인 존재로 만들면 되는 것이 이 장의 핀트입니다.

자율성을 높이자

해결 방법은 Audience와 TicketSeller가 직접 Bag과 TicketOffice를 처리하는 자율적인 존재가 되도록 설계를 변경하는 것입니다.

첫 번째 단계는 Theater의 enter 메소드에서 TicketOffice에 접근하는 모든 코드를 TicketSeller 내부로 숨기는 것입니다. TicketSeller에 sellTo 메소드를 추가하고 Theater에 있던 로직을 이 메서드로 옮깁니다.

public void enter(Audience audience){

    if(audience.getBag().hasInvitation()){
        Ticket ticket = ticketSeller.getTicketOffice().getTicket();
        audience.getBag().setTicket(ticket);
    }else {
        Ticket ticket = ticketSeller.getTicketOffice().getTicket();
        audience.getBag().minusAmount(ticket.getFee());
        ticketSeller.getTicketOffice().plusAmount(ticket.getFee());
        audience.getBag().setTicket(ticket);
    }
}
---------------------변 경 전 후 ------------------------
package object;

public class TicketSeller {

    private TicketOffice ticketOffice;

    public TicketSeller(TicketOffice ticketOffice) {
        this.ticketOffice = ticketOffice;
    }

    public void sellTo(Audience audience){
        if(audience.getBag().hasInvitation()){
            Ticket ticket = ticketOffice.getTicket();
            audience.getBag().setTicket(ticket);
        }else{
            Ticket ticket = ticketOffice.getTicket();
            audience.getBag().minusAmount(ticket.getFee());
            ticketOffice.plusAmount(ticket.getFee());
            audience.getBag().setTicket(ticket);
        }
    }
}

TicketSeller에서 getTicketOffice 메소드가 제거됐다는 사실에 주목합시다. ticketOffice의 가시성이 private이고 접근 가능한 퍼블릭 메소드가 더이상 존재하지 않기 때문에 외부에서 ticketOffice에 직접 접근할 수 없습니다.
결과적으로 ticketOffice에 대한 접근은 오직 ticketSeller 안에만 존재하게 됩니다. 따라서 TicketSeller는 ticketOffice에서 티켓을 꺼내거나 판매 요금을 적립하는 일을 스스로 수행할 수밖에 없습니다.

이처럼 개념적이거나 물리적으로 객체 내부의 세부적인 사항을 감추는 것을 캡슐화(encapsulation)이라고 부릅니다. 캡슐화의 목적은 변경하기 쉬운 객체를 만드는 것입니다. 캡슐화를 통해 객체 내부로의 접근을 제한하면 객체와 객체 사이의 결합도를 낮출 수 있기 때문에 설계를 좀 더 쉽게 변경할 수 있게 됩니다.

이제 Theater의 enter 메소드는 sellTo 메소드를 호출하는 간단한 코드로 변경됩니다.

package object;

public class Theater {

    private TicketSeller ticketSeller;

    public Theater(TicketSeller ticketSeller) {
        this.ticketSeller = ticketSeller;
    }


    public void enter(Audience audience){
        ticketSeller.sellTo(audience);
    }
}

이제는 Theater는 TicektOffice가 TicketSeller 내부에 존재한다는 사실을 알지 못합니다. Theater는 단지 ticketSeller가 sellTo 메시지를 이해하고 응답할 수 있다는 사실만 알고 있을 뿐입니다.

Theater는 오직 TicketSeller의 인터페이스(interface)에만 의존합니다. TicketSeller가 내부에 ticketOffice 인스턴스를 포함하고 있다는 사실은 구현의 영역에 속합니다. 객체를 인터페이스와 구현(implementation)으로 나누고 인터페이스만을 공개하는 것은 객체 사이의 결합도를 낮추고 변경하기 쉬운 코드를 작성하기 위해 따라야 하는 가장 기본적인 설계 원칙입니다.

Theater의 결합도를 낮춘 설계

위의 그림은 수정 후의 클래스 사이의 의존성을 나타낸 것입니다. Theater의 로직을 TicketSeller로 이동시킨 결과, Theater에서 TicketOffice로의 의존성이 제거됐다는 사실을 알 수 있습니다. TicketOffice와 협력하는 TicketSeller의 내부 구현이 성공적으로 캡슐화 된 것입니다.

아제 Audience의 캡슐화를 개선해야 합니다. TicketSeller는 Audience의 getBag 메소드를 호출해서 Audience 내부의 Bag 인스턴스에 직접 접근합니다. Bag 인스턴스에 접근하는 객체가 Theater에서 TicketSeller로 바뀌었을 뿐 Audience는 여전히 자율적인 존재가 아닌 것입니다.

TicketSeller와 동일한 방법으로 Audience의 캡슐화를 개선할 수 있습니다. Bag에 접근하는 모든 로직을 Audience 내부로 감추기 위해 Audience에 buy 메소드를 추가하고 TicketSeller의 sellTo 메소드에서 getBag 메소드에 접근하는 부분을 buy 메소드로 옮겨 보겠습니다.

package object;

public class Audience {

    private Bag bag;

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

    public Bag getBag() {
        return bag;
    }

    public Long buy(Ticket ticket) {
        if (bag.hasInvitation()) {
            bag.setTicket(ticket);
            return 0L;
        } else {
            bag.setTicket(ticket);
            bag.minusAmount(ticket.getFee());
            return ticket.getFee();
        }
    }
}

변경된 코드에서 Audience는 자신의 가방 안에 초대장이 들어있는지를 스스로 확인합니다. 외부의 제3자가 자신의 가방을 열어보도록 허용하지 않습니다. Audience가 직접 Bag을 처리하기 때문에 외부에서는 더 이상 Audience가 Bag을 소유하고 있다는 사실을 알 필요가 없습니다.

이제 TicketSeller가 Audience의 인터페이스에만 의존하도록 수정하면 됩니다.TicketSeller가 buy 메서드를 호출하도록 코드를 변경하면 됩니다.

package object;

public class TicketSeller {

    private TicketOffice ticketOffice;

    public TicketSeller(TicketOffice ticketOffice) {
        this.ticketOffice = ticketOffice;
    }


    public void sellTo(Audience audience){
        ticketOffice.plusAmount(audience.buy(ticketOffice.getTicket()));
    }

}

코드를 수정한 결과, TicketSeller와 Audience 사이의 결합도가 낮아졌습니다. 또한 내부 구현이 캡슐화 됐으므로 Audience의 구현을 수정하더라도 TicketSeller에는 영향을 미치지 않습니다.

캡슐화를 개선한 후에 가장 크게 달라진 점은 Audience와 TicketSeller가 내부 구현을 외부에 노출하지 않고 자신의 문제를 스스로 책임지고 해결한다는 것입니다.
다시 말해 자율적인 존재가 된 것입니다.

무엇이 개선됐는가

수정된 Audience와 TicketSeller는 자신이 가지고 있는 소지품을 스스로 관리합니다. 이것은 우리의 예상과도 정확하게 일치합니다. 따라서 코드를 읽는 사람과의 의사소통이라는 관점엣허 이 코드는 확실히 개선된 것으로 보입니다.
더 중요한 점은 Audience나 TicketSeller의 내부 구현을 변경하더라도 Theater를 함께 변경할 필요가 없다는 것입니다. Audience가 가방이 아니라 작은 지갑을 소지하도록 코드를 변경하고 싶으면 Audience 내부만 변경하면 됩니다.
TicketSeller가 매표소가 아니라 은행에 돈을 보관하도록 만들고 싶으면 TicketSeller 내부만 변경하면 됩니다.

어떻게 한 것인가

간단하게 판매자가 티켓을 판매하기 위해 TicketOffice를 사용하는 모든 부분을 TicketSeller 내부로 옮기고, 관람객이 티켓을 구매하기 위해 Bag을 사용하는 모든 부분은 Audience 내부로 옮겼습니다. 다시 말해 자기 자신의 문제를 스스로 해결하도록 코드를 변경하였습니다. 우리는 우리의 직관을 따랐고 그 결과로 코드는 변경이 용이하고 이해 가능학도록 수정됐습니다.

우리는 객체의 자율성을 높이는 방향으로 설계를 개선했습니다. 그 결과, 이해하기 쉽고 유연한 설계를 얻을 수 있었습니다.

캡슐화와 응집도

핵심은 객체 내부의 상태를 캡슐화하고 객체 간에 오직 메시지를 통해서만 상호작용하도록 만드는 것입니다. Theater는 TicketSeller의 내부에 대해서는 전혀 알지 못합니다.단지 TicketSeller가 sellTo 메시지를 이해하고 응답할 수 있다는 사실만 알고 있을 뿐입니다. TicketSeller 역시 Audience의 내부에 대해서는 전혀 알지 못합니다. 단지 Audience가 buy 메시지에 응답할 수 있고 자신이 원하는 결과를 반환할 것이라는 사실만 알고 있을 뿐입니다.

밀접하게 연관된 작업만을 수행하고 연관성 없는 작업은 다른 객체에게 윙미하는 객체를 가리켜 응집도(cohesion)가 높다고 말합니다. 자신의 데이터를 스스로 처리하는 자율적인 객체를 만들면 결합도를 낮출 수 있을뿐더러 응집도를 높일 수 있다.

외부의 간섭을 최대한 배제하고 메시지를 통해서만 협력하는 자율적인 객체들의 공동체를 만드는 것이 훌륭한 객체지향 설계를 얻을 수 있는 지름길 입니다.

절차지향과 객체지향

수정하기 전의 코드에서 Audience, TicketSeller, Bag, TicketOffice는 관람객을 입장시키는데 필요한 정보를 제공하고 모든 처리는 Theater의 enter 메소드안에 존재했습니다.

이 관점에서 Theater의 enter 메소드는 프로세스이며 Audience, TicketSeller,Bag, TicketOffice는 데이터 입니다. 이처럼 프로세스와 데이터를 별도의 모듈에 위치시키는 방식을 절차적 프로그래밍이라고 부릅니다.

절차적 프로그래밍 세상에서는 데이터 변경으로 인한 영향을 지역적으로 고립시키기 어렵다는 것입니다. Audience, TicketSeller의 내부 구현을 변경하려면 Theater의 enter 메소드를 함께 변경해야 합니다. 변경은 버그를 부르고 버그에 대한 두려움은 코드를 변경하기 어렵게 만듭니다. 따라서 절차적 프로그래밍 세상은 변경하기 어려운 코드를 양산하는 경향이 있습니다.

변경하기 쉬운 설계는 한 번에 하나의 클래스만 변경할 수 있는 설계입니다. 절차적 프로그래밍은 프로세스가 필요한 모든 데이터에 의존해야 한다는 근본적인 문제점 때문에 변경에 취약할 수 밖에 없습니다.

수정한 후의 코드에서는 데이터를 사용하는 프로세스가 데이터를 소유하고 있는 Audience와 TicketSeller 내부로 옮겨졌습니다. 이처럼 데이터와 프로세스가 동일한 모듈 내부에 위치하도록 프로그래밍 하는 방식을 객체지향 프로그래밍이라고 부릅니다.

책임의 이동

두 방식 사이에 근본적인 차이를 만드는 것은 책임의 이동입니다. 여기서는 책임을 기능을 가리키는 객체지향 세계의 용어로 생각해도 무방합니다.

두 방식의 차이점을 가장 쉽게 이해할 수 있는 방법은 기능을 처리하는 방법을 살펴보는 것입니다.

책임이 중앙집중된 절차적 프로그래밍

위의 절차지향 프로그래밍 처리 흐름도 그림에서 알수 있듰이 작업 흐름이 주로 Theater에 의해 제어된다는 사실을 알 수 있습니다.
객체지향 세계의 용어를 사용해서 표현하면 책임이 Theater에 집중돼 있는 것입니다.

책임이 분산된 객체지향 프로그래밍

그에 반해 객체지향 설계에서는 제어 흐름이 각 객체에 적절하게 분산돼 있음을 알 수 있습니다. 다시 말해 하나의 기능을 완성하는데 필요한 책임이 여러 객체에 걸쳐 분산돼 있는 것입니다.

변경 전의 절차적 설계에서 Theater가 전체적인 작업을 도맡아 처리했습니다. 변경 후의 객체 지향 설계에서는 각 객체가 자신이 맡은 일을 스스로 처리했습니다. 다시 말해 Theater에 몰려 있던 책임이 개별 객체로 이동한 것 입니다. 이것이 바로 책임의 이동이 의미하는 것입니다.

이렇게 객체지향적으로 코드를 작성하면서 더 즐거운 일은 코드가 더 이해하기 쉬워졌다는 점입니다. TicketSeller의 책임은 티켓을 판매하는 것이고, Audience는 티켓을 사는 책임을 가졌습니다. Theater는 관람객을 입장시키는 책임을 가졌습니다. 적절한 객체에 적절한 책임을 할당하면 이해하기 쉬운 구조와 읽기 쉬운 코드를 얻게 됩니다.

설계를 어렵게 만드는 것은 의존성이라는 것을 기억해야 합니다. 해결 방법은 불필요한 의존성을 제거함으로써 객체 사이의 결합도를 낮추는 것입니다. 예제코드에서 결합도를 낮추기 위해 선택한 방법은 Theater가 몰라도 되는 세부사항을 Audience와 TicketSeller 내부로 감춰 캡슐화하는 것입니다. 결과적으로 불필요한 세부사항을 객체 내부로 캡슐화하는 것은 객체의 자율성을 높이고 응집도 높은 객체들의 공동체를 창조할 수 있게 합니다.

더 개선할 수 있다

현재의 설계는 이전의 설계보다 분명히 좋아졌지만 아직도 개선의 여지가 있습니다. Audience 클래스를 살펴보겠습니다.

package object;

public class Audience {

    private Bag bag;

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


    public Long buy(Ticket ticket) {
        if (bag.hasInvitation()) {
            bag.setTicket(ticket);
            return 0L;
        } else {
            bag.setTicket(ticket);
            bag.minusAmount(ticket.getFee());
            return ticket.getFee();
        }
    }
}

Audience는 분명 자율적인 존재입니다. 스스로 티켓을 구매하고 가방 안의 내용물을 직접 관리합니다. 하지만 Bag은 Audience처럼 스스로 자기 자신을 책임지지 않고 Audience에 끌려다니는 수동적인 존재입니다. 여기서... 이부분을 눈치채신다면 그대는 객체지향의.. 빡고수의 자질을 가지신겁니다.. 전 몰랐습니다.. 아직 많이 부족한걸 느끼네요

다시 Bag을 자율적인 존재로 바꿔보겠습니다. 방법은 이전과 동일합니다. Bag 내부 상태에 접근하는 모든 로직을 Bag 안으로 캡슐화해서 결합도를 낮추면 됩니다. Bag에 hold 메소드를 추가해보겠습니다.

package object;

public class Bag {

    private Long amount;
    private Ticket ticket;
    private Invitation invitation;

    // 이벤트 당첨자인지 확인하는 비즈니스 로직
    public Long hold(Ticket ticket) {

        if (hasInvitation()) {
            setTicket(ticket);
            return 0L;
        } else {
            minusAmount(ticket.getFee());
            setTicket(ticket);
            return ticket.getFee();
        }
    }

    // 초대장이 있습니까?
    private boolean hasInvitation() {
        return this.invitation != null;
    }

    // 현금 감소
    private void minusAmount(Long amount) {
        this.amount -= amount;
    }

    //티켓 교환
    private void setTicket(Ticket ticket) {
        this.ticket = ticket;
    }
}

public 메소드였던 hasInvitation, minusAmount, setTicket 메소드들은 더 이상 외부에서 사용되지 않고 내부에서만 사용되기 때문에 가시성을 private로 변경했습니다. 이 작은 메소드들은 제거하지 않고 그대로 유지한 이유는 코드의 중복을 제거하고 표현력을 높이기 위해서 입니다.

Bag의 구현을 캡술화 시켰으니 이제 Audience를 Bag의 구현이 아닌 인터페이스에만 의존하도록 수정합니다.

package object;

public class Audience {

    public Long buy(Ticket ticket) {
       return bag.hold(ticket);
    }
}

TicketSeller 역시 TicketOffice의 자율권을 침해합니다. 아래 코드에서 알 수 있듯이 현재의 TicketSeller는 TicketOffice에 있는 Ticket을 마음대로 꺼내서는 자기 멋대로 Audience에게 팔고 Audience에게 받은 돈을 마음대로 TicketOffice에 넣어 버립니다.

package object;

public class TicketSeller {

    public void sellTo(Audience audience){
        ticketOffice.plusAmount(audience.buy(ticketOffice.getTicket()));
    }

}

잃어버린 TicketOffice의 자율권을 찾아보겠습니다. TicketOffice에 sellTicketTo 메소드를 추가하고 TicketSeller의 sellTo 메소드의 내부 코드를 이 메소드로 옮기면 됩니다. 이제 getTicket 메서드와 plusAmount 메소드는 TicketOffice 내부에서만 사용되기 때문에 가시성을 public에서 private로 변경할 수 있습니다.

public class TicketOffice {


    public void sellTicketTo(Audience audience){
        plusAmount(audience.buy(getTicket()));

    }


    private Ticket getTicket(){
        return this.tickets.remove(0);
    }


    private void plusAmount(Long amount){
        this.amount += amount;
    }
}

TicketSeller는 TicketOffice의 sellTicketTo 메소드를 호출함으로써 원하는 목적을 달성할 수 있습니다. 좋은 소식은 이제 TicketSeller가 TicketOffice의 구현이 아닌 인터페이스에만 의존하게 됐다는 점입니다

package object;

public class TicketSeller {

    public void sellTo(Audience audience){
        ticketOffice.sellTicketTo(audience);
    }
}

하지만 여기서 끝이 아닙니다... 안타깝게도 처음에 생각했던 것만큼 만족스럽지가 않습니다. 그 이유는 TicketSeller와 Audience 사이에 의존성이 추가됐기 때문입니다. 변경 전에는 TicketOffice가 Audience에 대해 알지 못했었다는 불편한 진실이 있습니다. 변경 후에는 TicketOfffice가 Audience에게 직접 티켓을 판매하기 때문에 Audience에 관해 알고 있어야 합니다.

TicketOffice에서 Audience로 향하는 의존성이 추가

현재로서는 Audience에 대한 결합도와 TicketOffice의 자율성 모두를 만족시키는 방법이 잘 떠오르지 않습니다. 트레이드오프 시점이 왔습니다. 여기에서는 자율성보다는 Audience에 대한 결합도를 낮추는 것이 더 중요하다는 결론에 도달했습니다.

이 작은 예제를 통해서 두 가지 사실을 알게 돼었습니다.

• 첫째, 어떤기능을 설계하는 방법은 한 가지 이상일 수 있습니다.
• 둘째, 동일한 기능을 한 가지 이상의 방법으로 설계할 수 있기 때문에 결국 설계는 트레이드오프의 산물입니다.

설계는 균형의 예술입니다. 훌륭한 설계는 적절한 트레이드 오프의 결과물이라는 사실을 명심해야 합니다. 이러한 트레이드오프 과정이 설계를 어려우면서도 흥미진진한 작업으로 만드는 것입니다.

참조:오브젝트 코드로 이해하는 객체지향 설계