Question

我有这种枚举

   public enum MyEnum {
        member1(MyClass1.class){
            @Override
            public void doStuff(Object obj) {
                ...
            }
        },
        member2(MyClass2.class){
            @Override
            public void doStuff(Object obj) {
                ...
            }
        };
        ...
        public abstract void doStuff(Object obj);
    }

我想要做的是在枚举中调用这个方法：

MyEnum.member1.doStuff(myObject);

并且枚举中的方法必须转换为对象。让我说我传入的myObject是MyClass1。 member1应该自动知道它只是期望MyClass1，它也在枚举成员描述中定义。

这样的事情是否可能，或者我走错了路？

Answer 1

public enum MyEnum {
   member1(String.class){
      @Override
      public void doStuff(Object obj) {
         this.checkArgumentType(obj);
         String stringObj = (String) obj;
         //...
      }
   },
   member2(Integer.class){
      @Override
      public void doStuff(Object obj) {
         this.checkArgumentType(obj);
         Integer stringObj = (Integer) obj;
         //...
      }

   };

   private final Class<?> clazz;

   MyEnum(Class<?> clazz) {
      this.clazz = clazz;
   }

   void checkArgumentType(Object obj) {
      if (!clazz.isAssignableFrom(obj.getClass())) {
         throw new IllegalArgumentException("Wrong class");
      }
   }

   //...
   public abstract void doStuff(Object obj);
}

Answer 2

类似的东西是可能的，但它会变得混乱而且复杂得快，直到你应该考虑创建单独的类。但作为一个例子，你可以做什么：

public enum Foo {

    member1(new Bar<String, Long>(Long.class){

        @Override
        void doStuff(String aString) {

        }

    });

    private final Bar<?,?> bar;

    private Foo(Bar<?,?> bar) {
        this.bar = bar;
    }

    private static abstract class Bar<A,B> {

        private final Class<B> type;

        Bar(Class<B> type) {
            this.type = type;
        }

        abstract void doStuff(A a);
    }
}

Answer 3

对于enum，您无法想到这一点。

理想情况下，您希望编译时类型安全。传递Object然后投射不是类型安全的;没有什么能阻止你传递错误类型的对象，直到运行时才会知道它，当你试图将对象转换为不是它时会得到ClassCastException。

枚举不能有类型参数，所以你不能对类型参数做任何事情，比如：

// This is not valid Java!
public enum MyEnum<T> {
    member1<MyClass> {
        @Override
        public void doStuff(MyClass obj) { ... }
    }

    // ...
    public abstract void doStuff(T obj);
}

如果你想要类型安全，只需使用一堆常量而不是enum：

interface MyConstant<T> {
    void doStuff(T obj);
}

public final class MyConstants {

    public static final MyConstant<MyClass1> MEMBER_1 = new MyConstant<MyClass1>() {
        @Override
        public void doStuff(MyClass1 obj) {
            // ...
        }
    };

    // etc.

    private MyConstants() {
    }
}

在枚举抽象方法中转换对象

3 个答案: