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

38. 확장할 수 있는 열거 타입이 필요하면 인터페이스 사용하기

열거 타입 자체는 확장할 수 없지만, 인터페이스와 그 인터페이스를 구현하는 기본 열거 타입을 함께 사용해 같은 효과를 낼 수 있음 

 

public interface Operation {
	double apply(double x, double y);
}

public enum BasicOperation implements 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;
    
    BasicOperation(String symbol) {
    	this.symbol = symbol;
    }
    
    @Override public String toString() {
    	return symbol;
    }
}

public enum ExtendedOperation implements Operation {
	EXP("^") {
    	public double apply(double x, double y) { return Math.pow(x, y); }
    },
    REMAINDER("%") {
    	public double apply(double x, double y) { return x % y; }
    };
    
    private final String symbol;
    
    ExtendedOperation(String symbol) {
    	this.symbol = symbol;
    }
    
    @Override public String toString() {
    	return symbol;
    }
}

---

✳️ 테스트 

public static void main(String[] args){
	double x = Double.parseDouble(args[0]);
    double y = Double.parseDouble(args[1]);
    test(ExtendedOperation.class, x, y);
}

private static <T extends Enum<T> & Operation> void test(Class<T> opEnumType, double x, double y) {
	for(Operation op : opEnumType.getEnumConstants())
    	System.out.printf("%f %s %f = %f%n", x, op, y, op.apply(x, y));
}

• opEnumType 매개변수의 선언 (<T extends Enum<T> & Operation> Class<T>)
  👉 Class 객체가 열거 타입인 동시에 Opertaion의 하위 타입이어야 한다는 뜻

public static void main(String[] args){
	double x = Double.parseDouble(args[0]);
    double y = Double.parseDouble(args[1]);
    test(Arrays.asList(ExtendedOperation.values()), x, y);
}

private static void test(Collection<? extends Operation> opSet, double x, double y) {
	for(Operation op : opSet)
    	System.out.printf("%f %s %f = %f%n", x, op, y, op.apply(x, y));
}

• Class 객체 대신 한정적 와일드카드 타입 넘김
• 덜 복잡하고 test 메서드가 살짝 더 유연해짐 👉 여러 구현 타입의 연산 조합해 호출 가능 
• 특정연산에서는 EnumSet과 EnumMap 사용 못함

---

✳️ 인터페이스로 확장 가능한 열거 타입 만들기의 단점 

• 열거 타입끼리 구현 상속 불가 
• Operation 예에서 연산 기호를 저장하고 찾는 로직이 BasicOperation과 ExtendedOperation 모두에 들어가야만 함
  • 현재는 중복량이 적지만, 공유하는 기능이 많아지면 그 부분을 별도의 도우미 클래스나 정적 도우미 메서드로 분리하는 방식으로 코드 중복을 줄여야 함

 

 

39. 명명 패턴보다 어노테이션 사용하기

✳️ 명명 패턴의 단점 

• 오타가 나면 안됨
• 올바른 프로그램 요소에서만 사용되리라 보증할 수 없음
• 프로그램 요소를 매개변수로 전달할 마땅한 방법이 없음

👉 어노테이션이 해결해줌

---

// 마커 어노테이션 타입 선언
import java.lang.annotation.*;

/**
* 테스트 메서드임을 선언하는 어노테이션
* 매개변수 없는 정적 메서드 전용
*/
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Test {
}

• 어노테이션 선언에 다는 어노테이션 = 메타어노테이션
• @Retention(RetentionPolicy.RUNTIME) : @Test가 런타임에도 유지되어야 한다는 표시 
• @Target(ElementType.METHOD) : @Test가 반드시 메서드 선언에서만 사용되어야 한다고 알려줌 👉 클래스 선언, 필드 선언 등 다른 프로그램 요소에 달 수 없음 

---

// 매개변수 하나를 받는 어노테이션 타입 
import java.lang.annotation.*;

/**
* 명시한 예외를 던져야만 성공하는 테스트 메서드용 어노테이션
*/
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface ExceptionTest {
	Class<? extends Throwable> value();
}

public class Sample2 {
	@ExceptionTest(ArithmeticException.class)
    public static void m1(){
    	int i = 0;
        i = i / i;
    }
    @ExceptionTest(ArithmeticException.class)
    public static void m2(){
    	int[] a = new int[0];
        int i = a[1];
    }
    @ExceptionTest(ArithmeticException.class)
    public static void m3(){  }
}

---

// 배열 매개변수를 받는 어노테이션 타입
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface ExceptionTest {
	Class<? extends Throwable>[] value();
}

@ExceptionTest({ IndexOutOfBoundsException.class, NullPointerException.class })
public static void doublyBad() {
	List<String> list = new ArrayList<>();
    
    list.addAll(5, null);
}

• 자바 8에서는 배열 매개변수를 사용하는 대신 어노테이션에 @Repeatable 메타어노테이션을 달면 됨
• @Repeatable을 단 어노테이션을 반환하는 '컨테이너 어노테이션'을 하나 더 정의하고, @Repeatable에 이 컨테이너 어노테이션의 class 객체를 매개변수로 전달해야 함
• 컨테이너 어노테이션은 내부 어노테이션 타입의 배열을 반환하는 value 메서드를 정의해야 함
• 컨테이너 어노테이션 타입에는 적절한 보존 정책(@Retention)과 적용대상(@Targe)을 명시해야 함

// 반복 가능한 어노테이션 타입
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@Repeatable(ExceptionTestContainer.class)
public @interface ExceptionTest {
	Class<? extends Throwable> value();
}

// 컨테이너 어노테이션
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface ExceptionTestContainer {
	ExceptionTest[] value();
}

// 반복 가능한 어노테이션 적용
@ExceptionTest(IndexOutOfBoundsException.class)
@ExceptionTest(NullPointerException.class)
public static void doublyBad() {...}

 

 

 

40. @Override 어노테이션을 일관되게 사용하기

@Override는 메서드 선언에서만 달 수 있고, 상위 타입의 메서드를 재정의했음을 의미함 

 

상위 클래스의 메서드를 재정의하려는 모든 메서드에 @Override 어노테이션을 다는 것 필수 !
👉 대부분의 IDE는 재정의할 메서드를 선택하면 자동으로 붙여주므로 참고

 

 

🚩 구체 클래스에서 상위 클래스의 추상 메서드를 재정의한 경우에는 어노테이션 굳이 달 필요 X

 

 

 

 

41. 정의하려는 것이 타입이라면 마커 인터페이스 사용하기

🌟 마커 인터페이스 : 아무 메서드도 담겨있지 않고, 단지 자신을 구현하는 클래스가 특정 속성을 가짐을 표시해주는 인터페이스로, 새로 추가하는 메서드 없이 단지 타입 정의가 목적일 때 주로 사용

 

✳️ 마커 인터페이스가 마커 어노테이션보다 나은 점 

• 마커 인터페이스는 이를 구현한 클래스의 인스턴스들을 구분하는 타입으로 사용 가능
• 적용 대상을 더 정밀하게 지정 가능 

// 직렬화 가능한 객체를 구분하기 위한 마커 인터페이스
public interface SerializableMarker {}

public class User implements SerializableMarker {
    private String name;

    public User(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

public class Product implements SerializableMarker {
    private String productName;

    public Product(String productName) {
        this.productName = productName;
    }

    public String getProductName() {
        return productName;
    }
}

public class Serializer {
    // 마커 인터페이스를 타입으로 받아 직렬화 가능한 객체만 처리
    public void serialize(SerializableMarker obj) {
        if (obj instanceof User) {
            System.out.println("Serializing User: " + ((User) obj).getName());
        } else if (obj instanceof Product) {
            System.out.println("Serializing Product: " + ((Product) obj).getProductName());
        } else {
            throw new IllegalArgumentException("Unsupported type for serialization");
        }
    }

    public static void main(String[] args) {
        Serializer serializer = new Serializer();

        User user = new User("Alice");
        Product product = new Product("Laptop");

        // 직렬화 가능한 객체만 처리 가능
        serializer.serialize(user);       // Output: Serializing User: Alice
        serializer.serialize(product);    // Output: Serializing Product: Laptop

        // serializer.serialize("Random String"); // 컴파일 오류
    }
}

✳️ 마커 어노테이션을 써야하는 경우

- 클래스와 인터페이스 외의 프로그램 요소(모듈, 패키지, 필드, 지역변수 등)에 마킹해야할 때
- 어노테이션을 활발히 활용하는 프레임워크