CODEWITHSUNDEEP
javaoopgenerics
madtyn
madtyn

Reputation: 1559

Java: How can I design this class for having optional generics ParameterType?

I have this class in my code

public abstract class MyAbstractEventListener<E extends IMyEvent> {
    public abstract void handleEvent(E e);
}

and I can make instances in this way (let's call it A):

new MyAbstractEventListener<IMyEvent>() {
    @Override
    public void handleEvent(final IMyEvent e) {
        // Method implementation
    }
};

But for my purposes, it would be ideal being able also to do this as well when there's no required event info (let's call this B):

new MyAbstractEventListener() { // Or receiving some unused parameter
    @Override
    public void handleEvent() {
        // Method implementation
    }
};

without having the warning about the class being raw and reccomending to parameterize it.

To clarify, I want the class to allow either the A or B instantiation, having the personal choice of using the one I prefer each time. If there's some generics parameter, the method receiving the IMyEvent object and if not, the method without parameters.

An example of code using this class would be:

EventBus.getInstance().addEventListener("some.string", new 
    AbstractEventListener<IMyEvent>() {
        @Override
        public void handleEvent(final IMyEvent e) {
            // Sometimes does use 'e', sometimes doesn't. That's the point
            MyConfirmationWindow.showConfirmationWindow(MyWindowType.WARNING, "kk", "lll");
        }
    });

Is there a way? Any link or resource will be appreciated.

Upvotes: 0

Views: 89

Answers (3)

tsolakp
tsolakp

Reputation: 5948

I don't think you will be able to avoid having tow handleEvent methods the way you described here.

But here is another approach using Null Object design pattern and single handleEvent method:

    new MyAbstractEventListener<IMyEvent>() {
        @Override
        public void handleEvent(final IMyEvent e) {
            // Method implementation
        }
    };

    new MyAbstractEventListener<NullIMyEvent>() {
        @Override
        public void handleEvent(final NullIMyEvent e) {
            // Method implementation
        }
    };        
    public interface IMyEvent{}

    public class NullIMyEvent implements IMyEvent{}

    public static abstract class MyAbstractEventListener<E extends IMyEvent> {
        public abstract void handleEvent(E e);
    }

Upvotes: 1

Timothy Truckle
Timothy Truckle

Reputation: 15624

public abstract class MyAbstractEventListener<E extends IMyEvent> {

But for my purposes, it would be ideal being able also to do this as well when there's no required event info (let's call this B):

The question is: what does the class MyAbstractEventListener do with the information that the parameter type E extends IMyEvent? Is there any method in that class working on type IMyEvent?

If not you could simple remove extends IMyEvent to achieve your goal.

Otherwise you need a different class since MyAbstractEventListener relies on type Eextending (or implementing) IMyEvent.

Upvotes: 0

bowmore
bowmore

Reputation: 11308

Well, you could make an abstract subclass : 

public abstract class BlindListener extends MyAbstractEventListener<IMyEvent> {

    public abstract void handleEvent();

    @Override
    public void handleEvent(IMyEvent iMyEvent) {
        handleEvent(); // delegate to abstract method that ignores the argument
    }
}

This is actually a class that uses generics, but clients won't ever have to deal with them :

new BlindListener() {
    @Override
    public void handleEvent() {

    }
}

Instances that do need a specific type can still use the MyAbstractEventListener directly

Upvotes: 2

Related Questions