枚举和通用定具体方法

Question

我有一个枚举，如：

enum TEST { 
     TEST1, TEST 2; 

     public abstract <T> String stringify (T input); 
    } 

我需要添加一个恒定的具体方法，像字符串化。

此方法将采用不同类型的输入（对于每个枚举）。我可以这样做吗？ Eclipse是不是让我做..something喜欢的：每个枚举值作为一类

enum TEST { 
    TEST1(
     public <Float> String stringify (Float input){ 
      return String.valueOf(input); 
     } 
    ) 
} 

Answer 1

思考。所以，是的，枚举可以有方法，就像一个类一样 - 但它们都有相同的方法。

http://download.oracle.com/javase/tutorial/java/javaOO/enum.html

看地球的例子。

还要注意，枚举本身可以有静态方法....（就像一个类）

Answer 2

不，你不能让每个枚举常量实现一个抽象的方法，但需要比其他类型的输入其他枚举常量。如果可以的话，如果给你的TEST枚举实例（你不知道它是什么常量），并试图对其调用stringify，会发生什么？你会通过什么类型的？

编辑：鉴于你说过这些枚举被用于字符串解码为对象，在我看来，你有几种选择：

• 你可以得到每个解码对象的String表示只需拨打toString()即可。
• 你可以在枚举类本身，所谓的stringify(Float)和stringify(Double)等添加一组重载的静态方法，那么你可以只调用TEST.stringify(value)，如果有该值的类型stringify方法，它会正常工作。

我想还有其他的选择。

Answer 3

你不能enum做吧，但是你可以用泛型类模拟这种行为：

public abstract class TEST<T> { 
    public static final TEST<Float> TEST1 = new TEST<Float>() { 
     public String stringify (Float input){ 
      return String.valueOf(input); 
     } 
    }; 

    public abstract <T> String stringify(T input); 
} 

Answer 4

你可以做到这一点。但目前还不清楚的好处是什么：

enum TEST { 
    TEST1 { 
     public <Float>String stringify(Float input) { 
      System.out.println("TEST1"); 
      return String.valueOf(input); 
     } 
    }, 
    TEST2 { 
     public <Integer>String stringify(Integer input) { 
      System.out.println("TEST2"); 
      return String.valueOf(input); 
     } 
    }, 
    TEST3 {}; 
    public <T>String stringify(T input) { 
     System.out.println("super"); 
     return ""; 
    } 
    public <Integer>String stringify2(Object input) { 
     System.out.println("non generic"); 
     return String.valueOf(input); 
    } 
} 
public class Main{ 
    public static void main(String[] args) { 
     for(TEST test:TEST.values()) { 
      System.out.println(test.stringify(new Float(1.23))); 
      System.out.println(test.stringify(new Integer(42))); 
      System.out.println(test.stringify(new Double(4.56))); 
     } 
     for(TEST test:TEST.values()) { 
      System.out.println(test.stringify2(new Float(1.23))); 
      System.out.println(test.stringify2(new Integer(42))); 
      System.out.println(test.stringify2(new Double(4.56))); 
     } 
    } 
} 

Answer 5

您不能使用泛型枚举，因为枚举常量本身已经是混凝土（单）的实例。在实例层面，仿制药必须具体。
所以，我会强烈建议使用其他答案中给出的替代方案之一。

如果您必须在枚举中执行此操作，您可以考虑以下内容，它至少为您提供了类型检查的运行时方法，其中包括ClassCastExceptions。尽管如此，你将不会得到编译器的任何支持。

public enum TestEnum { 
    Test1(Float.class), 
    Test2(Integer.class), 
    Test3(String.class); 

    private final Class<?> iInputType; 

    private TestEnum(final Class<?> pInputType) { 
     iInputType = pInputType; 
    } 

    public Class<?> getInputType() { 
     return iInputType; 
    } 

    public String stringify(final Object pInput) { 
     return String.valueOf(iInputType.cast(pInput)); 
    } 
} 

测试代码：

System.out.println(TestEnum.Test1.stringify(1.23f)); 
System.out.println(TestEnum.Test2.stringify(42)); 
System.out.println(TestEnum.Test3.stringify("foo")); 
// but: 
// System.out.println(TestEnum.Test1.stringify("foo")); // -> ClassCastException! 

for (TestEnum test : TestEnum.values()) { 
    for (Object input : new Object[]{1.23f, 42, "foo"}) { 
     if (test.getInputType().isAssignableFrom(input.getClass())) { 
      System.out.println(test.stringify(input)); 
     } 
    } 
}