int 상수 대신 열거 타입을 사용하라 - [6장. 열거 타입과 애너테이션(아이템34)] - (2)

  이전 글을 통해 '정수 열거 패턴의 단점, 열거 타입의 장점, 열거 타입의 기본 사용법'을 알아보았다.

  이번 글에서는 열거 타입의 다양한 기능들에 대해서 알아보도록 하자.

 

📙 1. 상수별 메서드 구현 (constant-specific method implementation)

  사칙연산 계산기와 같이 상수마다 동작이 달라져야 하는 경우가 있다. 가장 간단하게 생각해 볼 수 있는 것은 switch문을 통하여 분기하는 방법이다.

public enum Operation {
    PLUS, MINUS, TIMES, DIVIDE;

    // 상수가 뜻하는 연산을 수행한다.
    public double apply(double x, double y) {
        switch(this) {
            case PLUS:
                return x + y;
            case MINUS:
                return x - y;
            case TIMES:
                return x * y;
            case DIVIDE:
                return x / y;
        }
        throw new AssertionError("알 수 없는 연산: " + this);
    }
}

  동작은 하지만 좋은 코드는 아니다. 마지막의 throw 문은 실제로는 도달할 일이 없지만 기술적으로는 도달할 수 있기 때문에 생략하면 컴파일조차 되지 않는다.

  또한, 새로운 상수를 추가하면 해당 case 문도 추가해야 하므로 깨지기 쉬운 코드이다. 새로운 상수를 추가했지만 case 문에 연산을 추가하지 않은 경우 컴파일은 된다. 하지만, 새로 추가한 연산을 수행하려 할 때 "알 수 없는 연산"이라는 런타임 오류를 내며 프로그램이 종료된다.

 

  열거 타입의 상수별 메서드 구현 방식을 이용하면 상수별로 다르게 동작하는 코드를 구현할 수 있다.

  열거 타입에 apply라는 추상 메서드를 선언하고 각 상수별로 클래스 몸체(constant-specific class body)를 재정의하면 된다.

public enum Operation {
    PLUS {
        public double apply(double x, double y) {
            return x + y;
        }
    },
    MINUS {
        public double apply(double x, double y) {
            return x - y;
        }
    },
    TIMES {
        public double apply(double x, double y) {
            return x * y;
        }
    },
    DIVIDE {
        public double apply(double x, double y) {
            return x / y;
        }
    };

    public abstract double apply(double x, double y);
}

  이렇게 하면 새로운 상수를 추가할 때 apply도 재정의해야 한다는 사실을 깜빡하기는 어려울 것이다. 또한, apply가 추상 메서드이므로 재정의하지 않았다면 컴파일 오류로 알려준다.

 

 

📙 2. toString 메서드 & fromString 메서드

  상수별 메서드 구현을 상수별 데이터와 결합할 수도 있다. 다음과 같이 Operation의 toString을 재정의해 해당 연산을 뜻하는 기호를 반환하도록 할 수 있다.

public enum Operation {
    PLUS("+") {
        public double apply(double x, double y) {
            return x + y;
        }
    },
    MINUS("-") {
        public double apply(double x, double y) {
            return x - y;
        }
    },
    TIMES("*") {
        public double apply(double x, double y) {
            return x * y;
        }
    },
    DIVIDE("/") {
        public double apply(double x, double y) {
            return x / y;
        }
    };

    private final String symbol;

    Operation(String symbol) {
        this.symbol = symbol;
    }

    @Override
    public String toString() {
        return symbol;
    }

    public abstract double apply(double x, double y);
}

public static void main(String[] args) {
    double x = 2d;
    double y = 4d;

    for(Operation op : Operation.values()) {
        System.out.printf("%f %s %f = %f\n", x, op, y, op.apply(x, y));
    }

    // 결과
    // 2.000000 + 4.000000 = 6.000000
    // 2.000000 - 4.000000 = -2.000000
    // 2.000000 * 4.000000 = 8.000000
    // 2.000000 / 4.000000 = 0.500000
}

 

 

  열거 타입에는 상수 이름을 입력받아 그 이름에 해당하는 상수를 반환해 주는 valueOf(String) 메서드가 자동 생성된다.

public static void main(String[] args) {

    Operation plus = Operation.valueOf("PLUS");
    System.out.println(plus); // +
}

 

 

  또한, toString이 반환하는 문자열을 해당 열거 타입 상수로 변환해 주는 fromString 메서드도 함께 제공할 수 있다.

public enum Operation {
    PLUS("+") {
        public double apply(double x, double y) {
            return x + y;
        }
    },
    MINUS("-") {
        public double apply(double x, double y) {
            return x - y;
        }
    },
    TIMES("*") {
        public double apply(double x, double y) {
            return x * y;
        }
    },
    DIVIDE("/") {
        public double apply(double x, double y) {
            return x / y;
        }
    };

    private final String symbol;

    Operation(String symbol) {
        this.symbol = symbol;
    }

    @Override
    public String toString() {
        return symbol;
    }

    public abstract double apply(double x, double y);

    private static final Map<String, Operation> stringToEnum =
        Stream.of(values()).collect(
            toMap(Object::toString, e -> e));

    // 지정한 문자열에 해당하는 Operation을 (존재한다면) 반환한다.
    public static Optional<Operation> fromString(String symbol) {
        return Optional.ofNullable(stringToEnum.get(symbol));
    }
}

public static void main(String[] args) {

    Optional<Operation> plusFromString = Operation.fromString("+");
    System.out.println(plusFromString.get()); // +
}

 

  Operation 상수가 stringToEnum 맵에 추가되는 시점은 열거 타입 상수 생성 후 정적 필드가 초기화될 때다.

 

 

📙 3. 전략 열거 타입

  상수별 메서드 구현에는 열거 타입 상수끼리 코드를 공유하기 어렵다는 단점이 있다.
  다음은 급여명세서에서 사용할 요일을 표현하는 열거 타입이다. 직원의 (시간당) 기본임금과 그날 일한 시간(분 단위)이 주어지면 일당을 계산해 주는 메서드를 가지고 있다. 주중에는 오버타임만큼 잔업수당이 주어지고, 주말에는 무조건 잔업수당이 주어진다.

public enum PayrollDay {
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY,
    SATURDAY, SUNDAY;

    private static final int MINS_PER_SHIFT = 8 * 60; // 8시간

    int pay(int minutesWorked, int payRate) {
        int basePay = minutesWorked * payRate;

        int overtimePay;
        switch(this) {
            case SATURDAY: // 주말 (무조건 잔업 수당으로 계산)
            case SUNDAY:
                overtimePay = basePay / 2;
                break;
            default: // 주중 (8시간 초과시 잔업 수당 주어짐)
                overtimePay = minutesWorked <= MINS_PER_SHIFT ?
                    0 : (minutesWorked - MINS_PER_SHIFT) * payRate / 2;
        }

        return basePay + overtimePay;
    }
}

  이 코드는 관리 관점에서 위험한 코드이다. 휴가와 같은 새로운 값을 열거 타입에 추가하려면 그 값을 처리하는 case 문을 잊지 말고 쌍으로 넣어줘야 하기 때문이다.

 

  해당 문제점을 해결하는 방법으로는 새로운 상수를 추가할 때 잔업수당 '전략'을 선택하도록 할 수 있다.

public enum PayrollDay {
    MONDAY(WEEKDAY), TUESDAY(WEEKDAY), WEDNESDAY(WEEKDAY), THURSDAY(WEEKDAY), FRIDAY(WEEKDAY),
    SATURDAY(WEEKEND), SUNDAY(WEEKEND);

    private final PayType payType;

    PayrollDay(PayType payType) {
        this.payType = payType;
    }

    int pay(int minutesWorked, int payRate) {
        return payType.pay(minutesWorked, payRate);
    }

    // 전략 열거 타입
    enum PayType {
        WEEKDAY {
            int overtimePay(int minsWorked, int payRate) {
                return minsWorked <= MINS_PER_SHIFT ? 0 :
                    (minsWorked - MINS_PER_SHIFT) * payRate / 2;
            }
        },
        WEEKEND {
            int overtimePay(int minsWorked, int payRate) {
                return minsWorked * payRate / 2;
            }
        };

        abstract int overtimePay(int mins, int payRate);
        private static final int MINS_PER_SHIFT = 8 * 60;

        int pay(int minsWorked, int payRate) {
            int basePay = minsWorked * payRate;
            return basePay + overtimePay(minsWorked, payRate);
        }
    }
}

  이 방법은 잔업수당 계산을 private 중첩 열거 타입(아래의 PayType)으로 옮기고 PayrollDay 열거 타입의 생성자에서 이 중 적당한 것을 선택한다.

  그러면 PayrollDay 열거 타입은 잔업수당 계산을 그 전략 열거 타입에 위임하여, switch 문이나 상수별 메서드 구현이 필요 없게 된다.

  위에서 살펴본 switch 문을 이용하는 방법보다 복잡하지만 더 안전하고 유연한다.

 

해당 글은 Joshua Bloch 님의 'Effective Java 3/E'를 참고하였습니다.