Effective Java

[Effective Java] 아이템34 - int 상수 대신 열거 타입을 사용하라

돌에 2022. 3. 9. 11:32

열거타입

: 일정 개수의 상수 값을 정의한 다음, 그 외의 값은 허용하지 않는 타입이다.

 

자바에서 열거 타입을 지원하기 전에는 다음 코드처럼 정수 열거 패턴(int enum pattern) 기법을 사용했다.

 

public static finalintAPPLE_FUJI = 0;
public static finalintAPPLE_PIPPIN = 1;
public static finalintAPPLE_GRANNY_SMITH = 2;

public static finalint ORANGE_NAVEL = 0;
public static finalint ORANGE_TEMPLE = 1;
public static finalint ORANGE_BLOOD = 2;

 

정수 열거 패턴 기법의 단점

  • 타입 안전을 보장할 방법이 없으며 표현력도 좋지 않다.
  • 별도 이름공간을 지원하지 않기 때문에 접두어를 사용해 충돌을 방지해야 한다.
  • 상수의 값이 변경될 경우 다시 컴파일해야 하기 때문에 프로그램이 깨지기 쉽다.
  • 정수 상수를 문자열로 출력하기가 까다롭다.
    → 문자열 열거 패턴(string enum pattern)을 사용해 상수의 의미를 문자열로 출력할 수 있지만,
    문자열 값을 그대로 하드코딩해야 하며 문자열 비교에 따른 성능 저하가 올 수 있다.

열거 패턴의 단점을 해소해주는 동시에 여러 장점을 안겨주는 대안이 바로 열거 타입(enum type)이다.

 

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

 

 

열거 타입의 장점

 

  • 싱글턴을 일반화한 형태이다.

    → 열거 타입 자체는 클래스이며, 상수 하나당 자신의 인스턴스를 하나씩 만들어 public static final 필드로 공개한다.
    클라이언트가 인스턴스를 직접 생성하거나 확장할 수 없으니 열거 타입 인스턴스들은 딱 하나씩만 존재함이 보장된다.

  • 컴파일타임 타입 안전성을 제공한다.

    → 위 코드의 Apple 열거 타입을 매개변수로 받는 메서드를 선언했다면, 건네받은 참조는 (null이 아니라면) Apple의 세 가지 값 중 하나임이 확실하다. 이때, 다른 타입의 값을 넘기려 하면 컴파일 오류가 발생한다.
     
  • 각자의 이름 공간이 존재해 이름이 같은 상수도 사용 가능하다.
     
  • 새로운 상수를 추가하거나 순서를 바꿔도 다시 컴파일하지 않아도 된다.
     
  • toString 메서드를 사용해 적합한 문자열을 출력할 수 있다.
     
  • 임의의 메서드나 필드를 추가할 수 있으며, 임의의 인터페이스를 구현할 수 있다.

 

열거 타입에 메서드나 필드를 추가한다면?

 

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),
	URANUS (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)

	// 중력상수(단위: iT3 / kg s사2)
	private static final double G = 6.67300E-11;
    
	// 생성자
	Planet(double mass, double radius) {
		this.mass = mass;
		this.radius = radius;
		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 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를 제공한다.

 

 

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

 

제거한 상수를 참조하지 않는 클라이언트에는 아무 영향이 없다.

제거한 상수를 참조하는 클라이언트는 재컴파일시 컴파일 오류가, 컴파일 하지 않으면 런타임에 오류가 발생한다.

 

 

상수마다 동작이 달라져야 하는 상황에서는?

 

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); // 실제로 도달할 일이 없다.
}
}

→ switch 문을 이용해 상수의 값에 따라 분기하는 방법

 

새로운 상수를 추가할 경우, 해당 case 문도 추가해야 한다.

추가하지 않으면 컴파일은 가능하지만 "알 수 없는 연산"이라는 런타임 오류가 발생하게 된다.

 

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

: 추상 메서드를 사용해 각 상수에서 자신에 맞게 재정의하는 방법이다.

 

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가 추상 메서드이므로 재정의하지 않을 경우 컴파일 오류가 발생한다.

 

 

public enum Operation {
	PLUS("+") {
		public double apply(double x, double y) { ret나 rn 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);
}

→ toString을 재정의해 해당 연산을 뜻하는 기호(symbol)을 반환하도록 한 예다.

 

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

한편, 열거 타입의 toString 메서드를 재정의하려거든, toString이 반환하는 문자열을 해당 열거 타입 상수로 변환해주는 fromString 메서드도 함께 제공하는 걸 고려해보자.

 

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));
}

→ 열거 타입용 fromString 메서드 구현

 

열거 타입 생성자가 실행되는 시점에는 정적 필드들이 아직 초기화되기 전이라, 자기 자신을 추가하지 못하게 하는 제약이 꼭 필요하다.

이 제약의 특수한 예로, 열거 타입 생성자에서 같은 열거 타입의 다른 상수에도 접근할 수 없다.

 

 

상수별 메서드 구현에는 열거 타입 상수끼리 코드를 공유하기 어렵다는 단점이 있다.

 

enum PayrollDay {
	MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY,
	SATURDAY, SUNDAY;
	private static final int MINS_PER_SHIFT = 8 * 60;
	int pay(int minutesWorked, int payRate) {
		int basePay = minutesWorked * payRate;
		int overtimePay;
		switch(this) {
			case SATURDAY: case SUNDAY: // 주말
				overtimePay = basePay / 2;
				break;
			default: // 주중
				overtimePay = minutesWorked <= MINS_PER_SHIFT ?
					0 : (minutesWorked - MINS_PER_SHIFT) * payRate / 2;
		}
		return basePay + overtimePay;
	}
}

→ int pay(): (시간당) 기본 임금과 그날 일한 시간(분 단위)이 주어지면 일당을 계산해주는 메서드

주중에 오버타임이 발생하면 잔업수당이 주어지고, 주말에는 무조건 잔업수당이 주어진다.

switch 문을 이용하면 case 문을 날짜별로 두어 이 계산을 쉽게 수행할 수 있다.

 

위 코드는 간결하지만 새로운 값을 추가할 경우 등 관리 관점에서는 위험한 코드다.

 

상수별 메서드 구현으로 급여를 정확히 계산하는 방법은 두 가지다.

첫째, 잔업수당을 계산하는 코드를 모든 상수에 중복해서 넣으면 된다.

둘째, 계산 코드를 평일용과 주말용으로 나눠 각각을 도우미 메서드로 작성한 다음, 각 상수가 자신에게 필요한 메서드를 적절히 호출하면 된다.

두 방식 모두 코드가 장황해져 가독성이 크게 떨어지고 오류 발생 가능성이 높아진다.

 

가장 깔끔한 방법은 새로운 상수를 추가할 때 잔업수당 ‘전략’을 선택하도록 하는 것이다. (= 전략 열거 타입 패턴)

 

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);
    		}
	}
}

→ PayrollDay 열거 타입은 잔업수당 계산을 그 전략 열거 타입에 위임한다.

 

 

switch 문은 열거 타입의 상수별 동작을 구현하는 데 적합하지 않다.

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

 

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

 

 

열거 타입을 언제 사용해야 할까?

 

필요한 원소를 컴파일타임에 다 알 수 있는 상수 집합이라면 항상 열거 타입을 사용하자.

 

열거 타입에 정의된 상수 개수가 영원히 고정 불변일 필요는 없다.

나중에 상수가 추가돼도 바이너리 수준에서 호환되도록 설계되었기 때문이다.

 

 

열거 타입은 확실히 정수 상수보다 뛰어나다. 더 읽기 쉽고 안전하고 강력하다. 대다수 열거 타입이 명시적 생성자나 메서드 없이 쓰이지만, 각 상수를 특정 데이터와 연결짓거나 상수마다 다르게 동작하게 할 때는 필요하다. 드물게는 하나의 메서드가 상수별로 다르게 동작해야 할 때도 있다. 이런 열거 타입에서는 switch 문 대신 상수별 메서드 구현을 사용하자. 열거 타입 상수 일부가 같은 동작을 공유한다면 전략 열거 타입 패턴을 사용하자.