[📕 Effective Java] 열거 타입과 어노테이션 上

34. int 상수 대신 열거 타입 사용하기

열거 타입 = 일정 개수의 상수 값을 정의한 다음, 그 외의 값은 허용하지 않는 타입

 

✴️ 열거 패턴의 단점 

• 타입 안전 보장 X
• 표현력 좋지 X
• 평범한 상수를 나열한 것이라 상수의 값이 바뀌면 클라이언트도 반드시 다시 컴파일해야 함
• 정수 상수는 문자열로 출력하기 까다로움

👉 열거 타입 (ENUM type)이 대안

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

---

✳️ 열거 타입  

• 열거 타입 자체는 클래스
• 상수 하나당 자신의 인스턴스를 하나씩 만들어 public static final 필드로 공개
• 밖에서 접근할 수 있는 생성자를 제공하지 않으므로 사실상 final
• 클라이언트가 인스턴스를 직접 생성하거나 확장할 수 없으므로 열거 타입 선언으로 만들어진 인스턴스들은 딱 하나씩만 존재 보장
  = 인스턴스 통제
• 컴파일타임 타입 안전성 제공 
• 각자의 이름 공간이 있어서 이름이 같은 상수도 공존 가능 

enum Color {
    RED, GREEN, BLUE
}

enum Direction {
    NORTH, SOUTH, EAST, WEST, RED
}

// Color.RED와 Direction.RED -> 공존 가능

• toString 메서드로 문자열 출력 
  • toString 메서드 재정의할 시 toString이 반환하는 문자열을 해당 열거 타입 상수로 변환해주는 fromString 메서드도 함께 제공하기 !
• 임의의 메서드나 필드 추가 가능
• 임의의 인터페이스 구현 가능

// 데이터와 메서드를 갖는 열거 타입 
public enum Planet {
    MERCURY(3.303e+23, 2.4397e6),
    VENUS(4.869e+24, 6.0518e6),
    EARTH(5.976e+24, 6.37814e6),
    MARS(6.421e+23, 3.3972e6),
    JUPITER(1.9e+27, 7.1492e7),
    SATURN(5.688e+26, 6.0268e7),
    URANUS(8.686e+25, 2.5559e7),
    NEPTUNE(1.024e+26, 2.4746e7);

    private final double mass;          // 행성의 질량 (킬로그램)
    private final double radius;        // 행성의 반지름 (미터)
    private final double surfaceGravity; // 행성의 표면 중력

    // 중력 상수 (단위: 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 getMass() {
        return mass;
    }

    public double getRadius() {
        return radius;
    }

    public double getSurfaceGravity() {
        return surfaceGravity;
    }

    // 주어진 질량을 기반으로 행성에서의 무게를 계산
    public double surfaceWeight(double mass) {
        return mass * surfaceGravity;
    }

    public static void main(String[] args) {
        double earthWeight = 70.0; // 예시로 지구에서 70kg인 사람
        double mass = earthWeight / Planet.EARTH.getSurfaceGravity();

        for (Planet p : Planet.values()) {
            System.out.printf("Weight on %s: %.2f N%n", p, p.surfaceWeight(mass));
        }
    }
}

👉 열거 타입 상수 각각을 특정 데이터와 연결 지으려면 생성자에서 데이터를 받아 인스턴스 필드에 저장하면 됨
필드를 public으로 선언해도 되지만, private으로 두고 별도의 public 접근자 메서드를 두는게 나음 ! (아이템 16)

 

 

• 열거 타입은 자신 안에 정의된 상수들의 값을 배열에 담아 반환하는 정적 메서드인 values 제공 👉 값들은 선언된 순서로 저장됨

---

✳️ 상수별 메서드 구현을 활용한 열거 타입 

public enum Operation {
    ADD {public double apply(double x, double y) {return x + y;}},
    SUBTRACT {public double apply(double x, double y) {return x - y;}},
    MULTIPLY { 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);
}

 

• 단점
  • 열거 타입 상수끼리 코드 공유 어려움

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

👉 휴가와 같은 새로운 값을 열거 타입에 추가하려면 그 값을 처리하는 case문을 잊지 말고 쌍으로 넣어줘야 함ㅠㅠ

---

✳️ 전략 열거 타입 패턴 

• 위와 같은 예시에서 새로운 상수를 추가할 때 잔업수당 '전략' 선택
• 잔업수당 계산을 private 중첩 열거 타입으로 옮기고, PayrollDay 열거 타입의 생성자에서 이중 적당한 것 선택 
• PayrollDay 열거 타입은 잔업수당 계산을 그 전략 열거 타입에 위임하여, switch 문이나 상수별 메서드 구현이 필요 X

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 minutesWorked, int payRate){
            	return minsWorked <= MINS_PER_SHIFT ? 0 : 
                	(minsWorked - MINS_PER_SHIFT) * payRate / 2;      
            }
        },
        
        WEEKEND {
        	int overtimePay(int minutesWorked, 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);
        }
    }
}

public class PayrollSystem {
    public static void main(String[] args) {
        // 각 날에 대해 근무한 시간과 급여율을 설정
        int payRate = 10; // 분당 급여율 (예: 10 단위)

        // 각 요일에 대한 근무 시간
        int minutesWorkedMonday = 480; // 8시간
        int minutesWorkedSaturday = 600; // 10시간
        int minutesWorkedSunday = 120; // 2시간

        // 급여 계산
        int mondayPay = PayrollDay.MONDAY.pay(minutesWorkedMonday, payRate);
        int saturdayPay = PayrollDay.SATURDAY.pay(minutesWorkedSaturday, payRate);
        int sundayPay = PayrollDay.SUNDAY.pay(minutesWorkedSunday, payRate);

        // 결과 출력
        System.out.println("Monday Pay: $" + mondayPay); // 출력: Monday Pay: $80
        System.out.println("Saturday Pay: $" + saturdayPay); // 출력: Saturday Pay: $50
        System.out.println("Sunday Pay: $" + sundayPay); // 출력: Sunday Pay: $20
    }
}

---

✨ 결론적으로, 열거 타입을 언제 써야 하나..?

👉 필요한 원소를 컴파일 타임에 다 알 수 있는 상수 집합이라면 항상 열거 타입 사용하기 !
열거 타입에 정의된 상수 개수가 영원히 고정 불변일 필요 X

 

 

 

 

35. ordinal 메서드 대신 인스턴스 필드 사용하기

대부분의 열거 타입 상수는 하나의 정숫값에 대응하며 해당 상수가 그 열거 타입에서 몇 번째 위치인지 반환하는 ordinal 메서드 제공
👉 유지보수 및 실용성이 떨어짐 

public enum Ensemble {
    SOLO, DUET, TRIO, QUARTET, QUINTET,
    SEXTET, SEPTET, OCTET, NONET, DECET;

    public int numberOfMusicians() { return ordinal() + 1; }
}

ordinal 메서드를 사용했을 때 단점이 있다. 

• 상수 순서에 의존 👉 새로운 상수를 중간에 추가하거나 순서를 바꾸면 기존의 ordinal 값도 바뀜
• 의미 부족
• 중간에 값을 비워둘 수 없음
• 가독성 저하 

public enum Ensemble {
    SOLO(1), DUET(2), TRIO(3), QUARTET,(4) QUINTET(5), 
    SEXTET(6), SEPTET(7), OCTET(8), DOUBLE_QUARTET(8), // 이미 사용중인 상수가 있어도 사용 가능
    NONET(9), DECET(10), TRIPLE_QUARTET(12); // 중간에 값을 비울 수 있음

    private final int numberOfMusicians;
    Ensemble(int size) { this.numberOfMusicians = size; }
    public int numberOfMusicians() { return ordinal() + 1; }
}

 

 

 

 

36. 비트 필드 대신 EnumSet 사용하기

• 비트 필드 사용 시 비트별 연산을 사용해 합집합과 교집합 같은 집합 연산을 효율적으로 수행 가능
• 정수 열거 상수의 단점을 그대로 지니며 해석하기 어려움 
• 최대 몇 비트가 필요한지를 API 작성 시 미리 예측하여 적절한 타입을 선택해야 함

public class Text{
  public static final int STYLE_BOLD = 1 << 0; // 1
  public static final int STYLE_ITALIC = 1 << 1; // 2
  public static final int STYLE_UNDERLINE = 1 << 2; // 4
  public static final int STYLE_STRIKETHROUGH = 1 << 3; // 5

  public void applyStyle(int styles){...}
}

---

✳️ EnumSet 

• Set 인터페이스 구현
• 타입 안전하고 다른 어떤 Set 구현체와도 함께 사용 가능

public class Text {
    public enum Style {BOLD, ITALIC, UNDERLINE, STRIKETHROUGH}

	// Set을 넘김
    public void applyStyles(Set<Style> styles) {...}

    public static void main(String[] args) {
        Text text = new Text();
        text.applyStyles(EnumSet.of(Style.BOLD, Style.ITALIC));
    }
}

• 왜 applyStyles 메서드는 EnumSet이 아닌 Set을 받았을까...
  👉 좀 특이한 클라이언트가 다른 Set 구현체를 넘기더라도 처리 가능하기 때문 !

 

 

 

 

37. ordinal 인덱싱 대신 EnumMap 사용하기 

class Plant {
    enum LifeCycle {
        ANNUAL, PERENNIAL, BIENNIAL // 한해살이, 여러해살이, 두해살이
    }

    final String name;
    final LifeCycle lifeCycle;

    public Plant(String name, LifeCycle lifeCycle) {
        this.name = name;
        this.lifeCycle = lifeCycle;
    }

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

정원에 심은 식물들을 배열 하나로 관리하고, 이들을 생애주기별로 묶을 때 총 3개의 집합(한해, 여러해, 두해)을 만들고 정원에 있는 각 식물을 해당 집합에 넣으면 된다. 

private void plantClassification(Plant[] garden) {
    Map<Plant.LifeCycle, Set<Plant>> plantsByLifeCycle = new EnumMap<>(Plant.LifeCycle.class);

    for (Plant.LifeCycle lc : Plant.LifeCycle.values()) {
        plantsByLifeCycle.put(lc, new HashSet<>());
    }

    for (Plant p : garden) {
        plantsByLifeCycle.get(p.lifeCycle).add(p);
    }

    System.out.println(plantsByLifeCycle);
}

// 출력결과
// {ANNUAL=[Marigold, Sunflower], PERENNIAL=[Rose, Tulip], BIENNIAL=[Parsley]}

• 내부에서 배열을 사용하고 내부 구현 방식을 안으로 숨겨서 Map의 타입 안전성과 배열의 성능을 모두 얻어냄
• 맵의 키인 열거 타입이 그 자체로 출력용 문자열 제공 

---

✳️ 스트림을 사용한 코드 - EnumMap을 이용해 데이터와 열거 타입 매핑

System.out.println(Arrays.stream(garden)
	.collect(groupingBy(p -> p.lifeCycle,
    	() -> new EnumMap<>(LifeCycle.class), toSet())));

• 만약 한해살이와 여러해살이 식물만 살고 두해살이는 없다면 EnumMap 버전에서는 맵을 3개 만들고, 스트림 버전에서는 2개만 만듦

---

✳️ ordinal 두 번 쓰기 ...?

public enum Phase {
    SOLID, LIQUID, GAS; //고체, 액체, 기체

  public enum Transition {
    MELT, FREEZE, BOIL, CONDENSE, SUBLIME, DEPOSIT; // 융해, 응고, 기화, 응결, 승화, 승화

    // 행은 from의 ordinal을, 열은 to의 ordinal을 인덱스로 사용
    private static final Transition[][] TRANSITIONS = {
      { null, MELT, SUBLIME }, // 고체는 융해, 승화
      { FREEZE, null, BOIL }, // 액체는 응고, 기화
      { DEPOSIT, CONDENSE, null },  // 기체는 승화, 응결
    };

    public static Transition from(Phase from, Phase to) {
      return TRANSITIONS[from.ordinal()][to.ordinal()];
    }
  }
}

• Phase나 Phase.Transition 열거 타입을 수정하면서 상전이 표 TRANSITIONS를 함께 수정하지 않거나 실수로 잘못 수정한다면 런타임 오류 발생 

✳️ 중첩 EnumMap으로 데이터와 열거 타입 쌍을 연결

public enum Phase {
    SOLID, LIQUID, GAS;

  public enum Transition {
    MELT(SOLID, LIQUID), FREEZE(LIQUID, SOLID),
    BOIL(LIQUID, GAS), CONDENSE(GAS, LIQUID),
    SUBLIME(SOLID, GAS), DEPOSIT(GAS, SOLID);

    private final Phase from;
    private final Phase to;

    Transition(Phase from, Phase to) {
      this.from = from;
      this.to = to;
    }

	// 상전이 맵 초기화
    private static final Map<Phase, Map<Phase, Transition>> m = 
      Stream.of(values()).collect(groupingBy(t -> t.from,() -> new EnumMap<>(Phase.class),
                             		toMap(t -> t.to, t -> t,
                                   	(x, y) -> y, () -> new EnumMap<>(Phase.class))));

    public static Transition from(Phase from, Phase to) {
      return m.get(from).get(to);
    }
  }
}

• 안쪽 맵은 이전 상태와 전이를 연결
• 바깥쪽 맵은 이후 상태와 안쪽 맵 연결 
• groupingBy 👉 전이를 이전 상태를 기준으로 묶음
• toMap 👉 이후 상태를 전이에 대응시키는 EnumMap 생성
• (x, y) -> y는 선언만 하고 실제로는 쓰이지 않음
• Transition.from(Phase.SOLID, Phase.LIQUID)를 호출하면 Transition.MELT가 반환

상전이 맵을 초기화하는 코드는 제법 복잡하지만, 새로운 상태인 PLASMA를 추가하게 된다면
상태목록에 PLASMA를 추가하고, 전이 목록에 IONIZE(GAS, PLASMA)와 DEIONIZE(PLASMA, GAS)만 추가하면 됨

 

✨ Collectors.groupingBy() 메서드가 3개의 매개변수를 가질 때

groupingBy(Function<? super T, ? extends K> classifier, 
           Supplier<M> mapFactory, 
           Collector<? super T, A, D> downstream)​

- 그룹화 결과를 특정 맵 타입으로 저장해야 할 때 (mapFactory)
- 각 그룹에 대해 고유한 수집 방법을 지정해야 할 때 (downstream)