자바 열거 형 확장하기

Question

자바 열거 형을 다룰 때 코드 재사용을위한 최적의 디자인 패턴에 관한 질문이 있습니다. 기본적으로 정적 비즈니스 컬렉션 (상수 집합)을 모델링하는 여러 열거 형을 정의 할 수 있지만 가능한 최소한의 코딩으로 동작을 공유하고 싶습니다.

추상 클래스의 클래스 상속을 사용하면이 작업을 쉽게 수행 할 수 있지만 Java enum을 확장 할 수 없으므로 (인터페이스 만 구현할 수 있기 때문에) 이러한 유형의 작업은 지루하고 많은 오류가 발생하기 쉬운 복사/붙여 넣기 작업 (복사 enum에서 enum까지의 코드). 모든 열거 형 사이에서 공유되어야하는 "비즈니스 논리"의 예에는 문자열 변환, 인스턴스 및 논리 비교 등이 포함됩니다.

지금 가장 좋은 방법은 비즈니스 인터페이스와 함께 도우미 클래스를 사용하는 것입니다. 지금까지 코드 복잡성을 줄였습니다 (모든 열거 형은 여전히 ​​도우미 클래스를 선언하고 호출해야하므로). 예제를 참조하십시오 (명확히하기 위해) :

public enum MyEnum { 
    A, B, C; 

    // Just about any method fits the description - equals() is a mere example 
    public boolean equals(MyEnum that) { 
     ObjectUtils.equals(this, that); 
    } 
} 

StackOverflowers는이 "언어 기능"을 어떻게 처리합니까?

Answer 1

동일한 작업을 수행하거나 열거 형을 최고 열거 형으로 결합합니다.

Java 8을 사용하면 더 쉬울 것입니다. 인터페이스 메소드에 default 구현을 정의하고 enum 인터페이스를 확장 할 수 있습니다.

Answer 2

유한 상태를 나타내는 경우를 제외하고는 거의 동작이 필요하지 않은 경우를 제외하고는 거의 enums입니다.

enums이 동작을 필요로하는 classes에 Factory으로 리팩터링 할 것을 제안합니다.

Answer 3

재사용 가능한 논리를 전용 (비 enum) 클래스로 이동 한 다음 열거 형을 해당 클래스에 위임 할 수 있습니다. 예를 들면 다음과 같습니다.

[참고 : PlusTwo extends PlusOne의 상속은 권장되지 않습니다 (b/c PlusTwo는 PlusOne이 아닙니다). 그것은 여기에 단지

public interface Logic { 
    public int calc(int n); 
} 

public static class PlusOne implements Logic { 
    public int calc(int n) { return n + 1; } 
} 

public static class PlusTwo extends PlusOne { 
    @Override 
    public int calc(int n) { return super.calc(n) + 1; } 
} 

public static enum X { 
    X1, X2; 
    public Logic logic; 

    public int doSomething() { 
    return logic.calc(10); 
    } 
} 

public static enum Y { 
    Y1, Y2; 
    public Logic logic; 

    public String doSomethingElse() { 
    return "Your result is '" + logic.calc(10) + "'"; 
    } 
} 

public static void main(String[] args) { 
    // One time setup of your logic: 
    X.X1.logic = new PlusOne(); 
    X.X2.logic = new PlusTwo(); 
    Y.Y1.logic = new PlusOne(); 
    Y.Y2.logic = new PlusTwo(); 

    System.out.println(X.X1.doSomething()); 
    System.out.println(X.X2.doSomething()); 
    System.out.println(Y.Y1.doSomethingElse()); 
    System.out.println(Y.Y2.doSomethingElse()); 
} 

Answer 4

이 조금 추한 보일 수 있습니다]. 기존의 논리를 확장 할 수 있다는 점을 설명하기 위해, 그러나 일반적으로 당신에게 필요한 기능을 제공 할 수 있습니다.

당신은 인터페이스

public interface MyEnumInterface<T extends Enum<T>> { 

    String getBusinessName(); 

    T getEnum(); 

} 

구현

public enum OneOfMyEnums implements MyEnumInterface<OneOfMyEnums>{ 

    X, Y, Z; 

    @Override 
    public String getBusinessName() { 
     return "[OneOfMyEnums]" + name(); 
    } 

    @Override 
    public OneOfMyEnums getEnum() { 
     return this; 
    } 

} 

그리고 유틸리티 클래스 대신에 당신의 부모 클래스를 가질 수 있습니다

public class MyEnumUtils { 

    public static <T extends Enum<T>> String doSomething(MyEnumInterface<T> e){ 
     e.getBusinessName(); // can use MyEnumInterface methods 
     e.getEnum().name(); // can use Enum methods as well 
     return null; 
    } 

}