[Effective Java] 34. int 상수 대신 열거 타입을 사용하라

EFFECTIVE JAVA(이펙티브 자바)

 

이 포스팅에서 작성하는 내용은 EFFECTIVE JAVA(이펙티브자바) 에서 발췌하였습니다.

---

아이템 34. int 상수 대신 열거 타입을 사용하라

 

열거타입

• 일정 개수의 상수 값을 정의하고 그 외의 값은 허용하지 않는 타입 ex) 사계절, 태양계의 행성 등

 

ex 1) 정수 열거 패턴 (취약한 코드)

public static final int APPLE_FUJI = 0;
public static final int APPLE_PIPPIN = 1;
public static final int APPLE_GRANNY_SMITH = 2;

public static final int ORANGE_NAVEL = 0;
public static final int ORANGE_TEMPLE = 1;
public static final int ORANGE_BLOOD = 2;

• 자바에서 열거타입을 지원하기 전에 이처럼 정수 상수를 한 묶음 선언해서 사용
• 타입 안전을 보장할 방법이 없으며 표현력도 좋지 않다.
• 오렌지를 건네야할 메서드에 사과를 보내고 동등 연산자로 비교하더라도 컴파일러는 아무런 경고를 일으키지 않는다.
• 사과용 상수의 이름은 APPLE_, 오렌지용 상수는 ORANGE_로 시작 (접두어를 사용해서 이름 충돌 방지)
• 정수 열거 패턴은 평범한 상수를 나열한 것뿐이라 컴파일하면 그 값이 클라이언트 파일에 그대로 새겨지는데, 상수의 값이 바뀌면 클라이언트도 반드시 다시 컴파일 해야 한다. → 컴파일을 다시 하지 않은 클라이언트의 경우 의도대로 작동X
• 정수 대신 문자열 상수를 사용하는 문자열 열거 패턴도 있지만 이것 또한 나쁘다.

 

ex 2) 단순한 열거 타입 예

public enum Apple {  FUJI, PIPPIN, GRANNY_SMITH }
public enum Orange { NAVEL, TEMPLE, BLOOD }

• 자바의 열거 타입은 완전한 형태의 클래스라서 단순한 정수값인 다른 언어의 열거 타입보다 훨씬 강력하다.
• 열거 타입 자체는 클래스이며, 상수 하나당 자신의 인스턴스를 하나씩 만들어 public static field 로 제공한다.
• 열거 타입은 밖에서 접근할 수 있는 생성자를 제공하지 않으므로 사실상 final 이다.
• 따라서 클라이언트가 인스턴스를 직접 생산하거나 확장할 수 없으니 열거 타입 선언으로 만들어진 인스턴스들은 딱 하나씩만 존재한다.

 

 

열거 타입 장점

• 컴파일 타입 안정성을 제공한다.
  • Apple 열거 타입을 매개변수로 받는 메서드를 선언했다면, 건네받은 참조는 (null이 아니라면) Apple의 세 가지 값 중 하나임이 확실하다.
  • 다른 타입의 값을 넘기려고 하면 컴파일 오류가 발생한다.
• 열거 타입에는 각자의 이름 공간이 있어서 이름이 같은 상수도 공존한다.
• 열거 타입에 새로운 상수를 추가하거나 순서를 바꿔도 다시 컴파일하지 않아도 된다.
  • 공개되는 것이 오직 필드의 이름 뿐이라, 정수 열거 패턴과 달리 상수 값이 클라이언트로 컴파일되어 각인되지 않기 때문
• 열거 타입의 toString 메서드는 적합한 문자열을 출력한다.
• 열거 타입에는 임의의 메서드나 필드를 추가할 수 있고, 임의의 인터페이스를 구현하게 할 수도 있다.
• Object 메서드들을 높은 품질로 구현해놨고, Comparable과 Serializble을 구현해놨으며 직렬화 형태도 잘 동작되게끔 구현됐다.

 

ex 3) 데이터와 메서드를 갖는 열거 타입

public enum Planet {
    MERCURY(3.302e+23,2.439e6),
    VENUS(4.869e+24,6.052e6),
    EARTH(5.975e+24, 6.378e6),
    MARS(6.419e+23,3.393e6),
    JUPITER(1.899e+27,7.149e7),
    SATURN(5.685e+26,6.027e7),
    URAUS(8.683e+25,2.556e7),
    NEPTUNE(1.024e+26,2.477e7);
 
    private final double mass;            // 질량 (단위 : 킬로그램)
    private final double radius;          // 반지름 (단위 : 미터)
    private final double surfaceGravity;  // 표면중력 (단위 : m / s^2)
 
    // 중력상수 (단위 : m^3 / kg s^2)
    private static final double G = 6.67300E-11;
 
    // 생성자 
    Planet(double mass, double radius) {
        this.mass = mass;
        this.radius = radius;
        this.surfaceGravity = G * mass / (radius * radius);
    }
 
    public double mass() {
        return mass;
    }
 
    public double radius() {
        return radius;
    }
 
    public double surfaceGravity() {
        return surfaceGravity;
    }
 
    public double surfaceWeight(double mass) {
        return mass * surfaceGravity; // F = ma
    }
}

• 각 행성에는 질량과 반지름이 있고, 이 두 속성을 이용해 표면 중력을 계산하는 메서드가 포함되어있다.
• 열거 타입 상수 각각을 특정 데이터와 연결지으려면 생성자에서 데이터를 받아 인스턴스 필드에 저장하면 된다.
• 열거 타입은 근본적으로 불변이라 모든 필드는 final이어야 한다. (필드를 public으로 선언해도 되지만, private 으로 두고 별도의 public 접근자 메서드를 두는 것이 낫다(아이템16))
• 열거 타입을 선언한 클래스 혹은 그 패키지에서만 유용한 기능은 private이나 package-private 메서드로 구현한다.
• 이렇게 구현된 열거 타입 상수는 자신을 선언한 클래스 혹은 패키지에서만 사용할 수 있게 된다.
• 일반 클래스와 마찬가지로, 그 기능을 클라이언트에 노출할 필요가 없다면 private으로 사용하고 필요하다면 package-privet 으로 선언하자. (아이템 15)
• 널리 쓰이는 열거 탕비은 톱레벨 클래스로 만들고, 특정 톱레벨 클래스에서만 쓰인다면 해당 클래스의 멤버 클래스로 만든다. ex) 소수 자릿수의 반올림 모드를 뜻하는 열거 타입인 java.math.RoundingMode 는 BigDecimal이 사용한지만, 반올림 모드는 BigDecimal과 관련 없는 영역에서도 유용한 개념이라 자바 라이브러리 설계자가 톱레벨로 올렸다.

 

ex 4) 어떤 객체의 지구에서의 무게를 입력받아 여덟 행성에서의 무게를 출력하는 코드

public class WeightTable {
   public static void main(String[] args) {
      double earthWeight = Double.parseDouble(args[0]);
      double mass = earthWeight / Planet.EARTH.surfaceGravity();
      for (Planet p : Planet.values())
         System.out.printf("%s에서의 무게는 %f이다.%n", p, p.surfaceWeight(mass));
   }
}

• 열거 타입은 자신 안에 정의된 상수들의 값을 배열에 담아 반환하는 정적 메서드인 values를 제공한다.
• 값들은 선언된 순서로 저장된다.
• 각 열거 타입 값의 toString 메서드는 상수 이름을 문자열로 반환하므로 println과 printf로 출력하기에 알맞다.

 

열거 타입에서 상수를 제거하는 경우

• 제거한 상수를 참조하지 않는 클라이언트에는 아무 영향이 없다.
• 제거한 상수를 참조하는 클라이언트의 경우 클라이언트 프로그램을 다시 컴파일하면 제거된 상수를 참조하는 줄에서 디버깅에 유용한 메시지를 담은 컴파일 오류가 발생한다.

 

ex 5) 상수별 메서드 구현을 활용한 열거 타입

public enum OperationEnum {
    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;
        }
    },
    DIVDE("/") {
        public double apply(double x, double y) {
            return x / y;
        }
    };
 
    private final String symbol;
 
    OperationEnum(String symbol) {
        this.symbol = symbol;
    }
 
    @Override
    public String toString() {
        return symbol;
    }
 
    public abstract double apply(double x, double y);
}

• 열거 타입은 상수별로 다르게 동작하는 코드를 구현할 수 있게 한다.
• 열거 타입에 위처럼 apply라는 추상 메서드를 선언하고 각 상수별 클라이언트 몸체, 즉 각 상수에서 자신에 맞게 재정의하는 방법이다. (이를, 상수별 메서드 구현이라 한다.)
• 열거 타입에는 상수 이름을 입력받아 그 이름에 해당하는 상수를 반환해주는 valueOf(String) 메서드가 자동 생성된다.

 

ex 6) 열거 타입용 fromString 메서드를 구현한 코드

private static final Map<String, Operation> stringToEnum =
            Stream.of(Operation.values())
                    .collect(Collectors.toMap(Operation::toString, operation -> operation));
 
// 지정한 문자열에 해당하는 Operation을 존재한다면 반환한다.
public static Optional<Operation> fromString(String symbol) {
    return Optional.ofNullable(stringToEnum.get(symbol));
}

• 열거 타입의 toString 메서드를 재정의하려거든, toString이 반환하는 문자열을 해당 열거 타입 상수로 변환해주는 formString 메서드도 함께 제공하는 걸 고려해보자.
• operation 상수가 stringToEnum 맵에 추가되는 시점은 열거 타입 상수 생성 후 정적 필드가 초기화될 때이다.
• 앞의 코드는 values 메서드가 반환하는 배열 대신 스트림을 사용했다.
• 자바 8이전에는 빈 해시맵을 만든 다음 values가 반환한 배열을 순회하며 {문자열, 열거 타입 상수} 쌍을 맵에 추가했을 것이다.
• 하지만, 열거 타입 상수는 생성자에서 자신의 인스턴스를 맵에 추가할 수 없다.
• 열거 타입의 정적 필드 중 열거 타입의 생성자에 접근할 수 있는 것은 상수 변수 뿐이다.
• 열거 타입 생성자가 실행되는 시점에는 정적 필드들이 아직 초기화되기 전이라, 자기 자신을 추가하지 못하게 하는 제약이 꼭 필요하다.
• 이 제약의 특수한 예로, 열거 타입 생성자에서 같은 열거 타입의 다른 상수에도 접근할 수 없다.
• fromString이 Optional<Operation>을 반환하는 점도 주의하자. 이는 주어진 문자열이 가리키는 연산이 존재하지 않을 수 있음을 클라이언트에 알리고, 그 상황을 클라이언트에서 대처하도록 한 것이다.

 

ex 7) 값에 따라 분기하여 코드를 공유하는 열거 타입

enum PayrolLDay {
    MONDAY, TUESDAY, WEDSENDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY:

    private static final int MINS_PER_SHIFT = 8 * 60;
    
    int pay(int minutesWorked, int payRate) {
        int basePay = minuitesWorked * payRate;
        
        int overtimePay;
        switch(this) {
            case SATURDAY: case SUNDAY:       // 주말
                overtimePay = basePay /2;
                break;
            default:    // 주중
                overtimePay = minuutesWorked <= MINS_PER_SHIFT ? 
									0 : (minutesWorked - MINS_PER_SHIFT) * payRate /  2;
        }

        return basePay + overtimePay;
    }
}

• 급여 명세서에서 쓸 요일을 표현하는 열거 타입이다. (이 열거 타입은 직원의 시간당 기본 임금과 그 날 일한 시간(분 단위)이 주어지면 일당을 계산하는 메서드를 가지고 있다.)
• 주중에 오버타임이 발생하면 잔업수당이 주어지고, 주말에는 무조건 잔업수당이 주어진다.
• 간결하지만 관리 관점에서는 위험한 코드이다.
• 휴가와 같은 새로운 값을 열거 타입에 추가하려면 그 값을 처리하는 case 문을 잊지 않고 넣어줘야하기 때문이다.
• 상수별 메서드 구현으로 급여를 정확하게 계산하는 방법은 두 가지이다. (아래의 방법은 코드가 장황해져 가독성이 떨어지고 오류 발생 가능성이 높아진다.)
  • 잔업 수당을 계산하는 코드를 모든 상수에 중복해서 넣으면 된다.
  • 계산 코드를 평일용과 주말용으로 나눠 각각을 도우미 메서드로 작성한 다음 각 상수가 자신에게 필요한 메서드를 적히 호출하면 된다.
• 그럴 땐 전략 열거 타입 패턴을 사용해보자 

 

 

ex 8) 전략 열거 타입 패턴

public enum PayrollDay {
    MONDAY,
    TUESDAY,
    WEDNESDAY,
    THURSDAY,
    FRIDAY,
    SATURDAY(PayType.WEEKEND),
    SUNDAY(PayType.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 minutesWorked, int payRate) {
                return minutesWorked <= MINS_PER_SHIFT ?
                        0 : (minutesWorked - MINS_PER_SHIFT) * payRate / 2;
            }
        },
        WEEKEND { // 주말
            int overtimePay(int minutesWorked, int payRate) {
                return minutesWorked * payRate / 2;
            }
        };
 
        abstract int overtimePay(int minutesWorked, int payRate);
        private static final int MINS_PER_SHIFT = 8 * 60;
 
        int pay(int minutesWorked, int payRate) {
            int basePay = minutesWorked * payRate;
            return basePay + overtimePay(minutesWorked,payRate);
        }
    }
}

• switch 문은 열거 타입의 상수별 동작을 구현하는 데 적합하지 않지만 기존 열거 타입에 상수별 동작을 혼합해 넣을 때는 switch 문이 좋은 선택이 될 수 있다.

 

 

ex 9) switch 문을 이용해 원래 열거 타입에는 없는 기능을 수행하는 코드

public static Operation inverse(Operation operation) {
		switch (operation) {
		    case PLUS:
		        return Operation.MINUS;
		    case MINUS:
		        return Operation.PLUS;
		    case TIMES:
		        return Operation.DIVDE;
		    case DIVDE:
		        return Operation.TIMES;
		}
		throw new AssertionError("알 수 없는 연산 : " +operation);
}

 

 

정리

• 필요한 원소를 컴파일타임에 다 알 수 있는 상수 집합이라면 항상 열거 타입을 사용하자
• 열거 타입에 정의된 상수 개수가 영원히 고정 불변일 필요는 없다.
• 열거 타입은 정수 상수보다 더 읽기 쉽고 강력하다.
• 열거 타입이 명시적 생성자나 메서드 없이 쓰이지만, 각 상수를 특정 데이터와 연결 짓거나 상수마다 다르게 동작하게 할 때는 필요하다.
• 드물게 하나의 메서드가 상수별로 다르게 동작해야할 때도 있다. 이런 열거 타입에서는 swtich문 대신 상수별 메서드 구현을 사용하자.
• 열거 타입 상수 일부가 같은 동작을 공유한다면 전략 열거 타입 패턴을 사용하자.