Casting objects in enum abstract methods

Question

I have this kind of enum

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

What I would like to do is call the method in the enum like this:

MyEnum.member1.doStuff(myObject);

And have the methods in enum which object it has to cast to. Lets say the myObject that I pass in is MyClass1. The member1 should know automatically that it is only expecting MyClass1 which is also defined in the enum member description.

Is something like this even possible or I am walking a completely wrong path?

Completely the wrong path. Sorry. Start at the beginning, as explain what it is you are trying to do, not how you are trying to do it... — Boris the Spider
– Boris the Spider, Commented Apr 12, 2016 at 14:38

Vampire · Accepted Answer · 2016-04-12 14:45:46Z

3

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

answered Apr 12, 2016 at 14:45

Vampire

39.2k4 gold badges84 silver badges112 bronze badges

Sign up to request clarification or add additional context in comments.

3 Comments

inimene Over a year ago

I like this. Thank you! The seconds answer was also interesting but it indeed gets a bit too crazy really fast.

Jesper Over a year ago

Note that this is not type-safe. You won't get an error at compile time when you pass the wrong type of object - you'll get an exception at runtime instead. In general it's better to catch errors at compile time instead of at runtime.

Vampire Over a year ago

Well, it is type-safe. It is just not compile-time type-safe.

SME_Dev · Accepted Answer · 2016-04-12 14:39:31Z

2

Something similar is possible, but it gets messy and complex real quick, up to the point where you should think about creating separate classes. But as an example, what you could do:

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

answered Apr 12, 2016 at 14:39

SME_Dev

1,89013 silver badges23 bronze badges

1 Comment

Vampire Over a year ago

Nice solution, though indeed a bit from behind, through the chest in the eye. :-D

Jesper · Accepted Answer · 2016-04-12 14:40:50Z

This is not possible with an enum in the way that you have it in mind.

Ideally you want to have compile-time type safety. Passing Object and then casting is not type-safe; nothing prevents you from passing a wrong kind of object, and you won't know it until runtime, when you get a ClassCastException when you try to cast the object to something that it's not.

Enums cannot have type parameters, so you cannot do anything with type parameters, like this:

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

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

If you want type-safety, just use a bunch of constants instead of an 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() {
    }
}

Collectives™ on Stack Overflow

Casting objects in enum abstract methods

3 Answers 3

3 Comments

1 Comment

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

3 Comments

1 Comment

Comments

Your Answer

Sign up or log in

Post as a guest

Related