Mở rộng Java Enums

Question

Tôi có một câu hỏi liên quan đến mẫu thiết kế tốt nhất để sử dụng lại mã khi xử lý các enum Java. Về cơ bản, những gì tôi đang cố gắng đạt được là có thể xác định một số enums mô hình hóa các bộ sưu tập kinh doanh tĩnh (bộ các hằng số), nhưng tôi cũng muốn chia sẻ hành vi giữa chúng, với mã hóa tối thiểu. Điều này là tầm thường để đạt được với kế thừa lớp từ lớp trừu tượng nhưng, vì Java enums không thể được mở rộng (họ chỉ có thể thực hiện giao diện), loại công việc này tẻ nhạt và liên quan đến rất nhiều công việc sao chép/dán dễ bị lỗi (sao chép). Quay lại đầu trang mã từ enum đến enum). Ví dụ về "logic nghiệp vụ" cần được chia sẻ giữa tất cả các enums bao gồm chuyển đổi từ/thành chuỗi, ví dụ và so sánh lôgic, v.v.

Ảnh tốt nhất hiện tại của tôi là sử dụng lớp trợ giúp kết hợp với giao diện kinh doanh, nhưng điều này chỉ cho đến nay trong việc giảm độ phức tạp của mã (vì tất cả các enums vẫn phải khai báo và gọi các lớp trợ giúp). Xem ví dụ (chỉ để làm rõ):

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

Làm thế nào để StackOverflowers đối phó với "tính năng ngôn ngữ" này?

Answer 1

Tôi sẽ làm tương tự, hoặc kết hợp Enums thành một siêu enum.

Với Java 8 việc này sẽ dễ dàng hơn. Bạn sẽ có thể xác định triển khai default cho các phương thức giao diện và mở rộng giao diện enum.

Answer 2

Tôi hiếm khi tìm thấy enums hữu ích, ngoại trừ đại diện cho các trạng thái hữu hạn trong trường hợp chúng không cần hành vi.

Tôi sẽ đề xuất tái cấu trúc enums cần hành vi vào classes với số Factory.

Answer 3

Bạn có thể di chuyển lôgic có thể tái sử dụng sang các lớp chuyên dụng (không phải enum) và sau đó có enums ủy nhiệm cho các lớp đó. Dưới đây là ví dụ:

[Ghi chú bên: không được khuyến khích thừa kế PlusTwo extends PlusOne (b/c PlusTwo không phải là PlusOne). Ở đây chỉ để minh họa quan điểm của việc có thể mở rộng một logic hiện có.]

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

Điều này có thể hơi xấu xí, nhưng thường có thể cung cấp cho bạn chức năng được yêu cầu.

Bạn có thể có giao diện

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

    String getBusinessName(); 

    T getEnum(); 

} 

Thực hiện

public enum OneOfMyEnums implements MyEnumInterface<OneOfMyEnums>{ 

    X, Y, Z; 

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

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

} 

Và tiện ích lớp thay vì lớp cha mẹ của bạn

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

}