如何实现Java枚举抽象类和接口？

Question

我有以下问题。 我有一个包含java中不同枚举类的包。

在添加所有枚举共有的新方法时，避免重复自我的正确方法是什么？

我的问题：

channel.java

public enum Channel { 
      channel1, channel2; 
    } 

color.java

public enum color{ 
      color1, color2; 
    } 

应在双方所采用的方法：

public static boolean contains(String channel) { 
     for (Channel c : Channel.values()) { 
      if (c.name().equals(channel)) { 
       return true; 
      } 
     } 
    return false; 
    } 

注意，循环有一个参考到枚举本身。所以，这需要复制并粘贴所有我想使用它的枚举的方法。 有什么建议吗？

感谢 维克多

Answer 1

我建议使用util的法像提到@Phil Anderson。我只会将其更改为普通模式：

public static <T extends Enum<T>> void some_method(Class<T> clazz, String name) { 
    try { 
     T foundEnum = Enum.valueOf(clazz, name); 
     // name matches to one of enum values, do something with it 
    } catch (IllegalArgumentException e) { 
     // name doesn't matches to any of enum values 
    } 
} 

这情况下包含的语义看起来是这样的：

public static <T extends Enum<T>> boolean contains(Class<T> clazz, String name) { 
    try { 
     Enum.valueOf(clazz, name); 
    } catch (IllegalArgumentException e) { 
     return false; 
    } 
    return true; 
} 

---

更新时间：

如前所述@phil-anderson，从性能的角度来看，这种方法有一定的缺点，因为异常的产生和抛出很慢（见How slow are Java exceptions?）。但是这只是一个例子，如果方法调用的值不正确name。

因此，在这种情况下，你可以使用此模式：

public static <T extends Enum<T>> void some_method(Class<T> clazz, String name) { 
    for (T each : clazz.getEnumConstants()) { 
     if (each.name().equals(name)) { 
      // name matches to one of enum values, do something with it 
     } 
    } 
    // name doesn't matches to any of enum values 
} 

此外，如果性能起着重要的作用，特别是如果枚举包含大量的值，它是没有效率的迭代（也许） 他们全部。该解决方案可能使用枚举的懒惰哈希映射并通过哈希码获取值。例如：

@SuppressWarnings("unchecked") 
public static <T extends Enum<T>> void some_method(Class<T> clazz, String name) { 
    Map<String, Enum<?>> enumMap = enumsMap.get(clazz); 
    if (enumMap == null) { 
     enumMap = new HashMap<String, Enum<?>>(); 
     for (T t : clazz.getEnumConstants()) { 
      enumMap.put(t.name(), t); 
     } 
     enumsMap.put(clazz, enumMap); 
    } 
    T t = (T) enumMap.get(name); 
    if (t != null) { 
     // name matches to one of enum values, do something with it 
    } else { 
     // name doesn't matches to any of enum values 
    } 
} 

Answer 2

您可以使用接口与静态方法来做到这一点：

public interface CanContainChannel { 
    static boolean contains(String channel) { 
     for (Channel c : Channel.values()) { 
      if (c.name().equals(channel)) { 
       return true; 
      } 
     } 
     return false; 
    } 
} 

而且你们两个你枚举可以实现此接口来获得这种方法，虽然我不确定你为什么想在你的Color枚举中使用这样的方法。

编辑：

在澄清的问题我这个问题，将帮助您： Iterate enum values using java generics

Answer 3

你不能做到这一点很要不幸的方法。 可以用做什么，就是拥有某种具有普通方法的util类。

例如...

public class EnumUtils { 

    public static boolean contains(Enum[] enumValues, String nameToCheck) { 

     for(Enum each : enumValues) { 
      if(each.name().equals(nameToCheck)) { 
       return true; 
      } 
     } 
     return false; 
    } 
} 

然后，你可以使用它像这样...

System.out.println(EnumUtils.contains(Channel.values(), "channel1")); // TRUE 
System.out.println(EnumUtils.contains(Color.values(), "octarine")); // FALSE 

警告 - 在更复杂的系统中，这些各种各样的静态UTIL类是有时有点的“代码味道”，但我认为你的情况很好。

对于的Java6：

 change each.name() => each.toString() 

Answer 4

使用反射可以获取枚举常量。

enum E { 
    i("unu"), ii("du"), iii("tri"), iv("kvar"); 

    public final String name; 

    E(String name) { 
     this.name = name; 
    } 
} 

public static void main(String[] args) { 
    // Normally in Java 8 for a concrete enum: 
    final String sought = "tri"; 
    boolean found = Stream.of(E.values()).anyMatch((c) -> c.name.equals(sought)); 

    // A generic function: 
    System.out.println("okay: " 
     + find(E.class, (c) -> c.name.equals(sought))); 
    System.out.println("fails: " 
     + find(E.class, (c) -> c.name.equals("prtl"))); 
} 

public static <T extends Enum<?>> boolean find(Class<T> clazz, 
     Predicate<T> predicate) { 
    return Stream.of(clazz.getEnumConstants()).anyMatch(predicate); 
} 

当你想要访问一个字段时，传递整个谓词更容易。

在java 7下，人们通常会更加严格（没有Stream），并且需要一个用于getName()等的接口。