Generic static factory

Question

I am getting a compilation error. I want my static method here to return a factory that creates and return Event<T> object. How can I fix this?

import com.lmax.disruptor.EventFactory;

public final class Event<T> {

    private T event;

    public T getEvent() {

        return event;
    }

    public void setEvent(final T event) {

        this.event = event;
    }

    public final static EventFactory<Event<T>> EVENT_FACTORY = new EventFactory<Event<T>>() {

        public Event<T> newInstance() {

            return new Event<T>();
        }


     };

}

So...what's an `EventFactory`? It looks like you're trying to use one before it's defined... — Makoto, Mar 29 '14 at 04:30
Maybe, the issue is that generic types cannot be bound to static objects. `Event` does not exist for a static member of `Event`. — bsd, Mar 29 '14 at 04:40
possible duplicate of [Static method in a generic class?](http://stackoverflow.com/questions/936377/static-method-in-a-generic-class) -- slightly different use case but same problem and explanation. — Jason C, Mar 29 '14 at 04:54

score 3 · Accepted Answer · answered Mar 29 '14 at 04:40

Generic parameters of a class do not apply to static members.

The obvious solution is to use a method rather than a variable.

public static <U> EventFactory<Event<U>> factory() {
    return new EventFactory<Event<U>>() {
        public Event<U> newInstance() {
            return new Event<U>();
        }
    };
}

The syntax is more concise in the current version of Java.

It is possible to use a the same instance of EventFactory stored in a static field, but that requires an unsafe cast.

Jason C · Answer 2 · 2014-03-29T04:49:29.230

You have:

public final class Event<T> {
    ...
    public final static EventFactory<Event<T>> EVENT_FACTORY = ...
}

You cannot do this. T is a type that is associated with a specific instance of an Event<T>, and you cannot use it in a static context.

It's hard to give you good alternate options without knowing more about what exactly you are trying to do, as this is sort of an odd-looking factory implementation. I suppose you could do something like (put it in a method instead):

public final class Event<T> {
    ...
    public static <U> EventFactory<Event<U>> createEventFactory () { 
        return new EventFactory<Event<U>>() {
            public Event<U> newInstance() {
                return new Event<U>();
            }
        };
    };
}

And invoke it like:

EventFactory<Event<Integer>> factory = Event.<Integer>createEventFactory();

Or, if you don't want to be explicit (you don't really need to be, here):

EventFactory<Event<Integer>> factory = Event.createEventFactory();

Why don't you get rid of the whole static member of Event thing and either keep the factories separate, e.g.:

public final class GenericEventFactory<T> extends EventFactory<Event<T>> {
    @Override public Event<T> newInstance() {
        return new Event<T>();
    }
}

And use, e.g., new GenericEventFactory<Integer>() where appropriate?

@TomHawtin-tackline True. I wanted to illustrate, but I added that in. — Jason C, Mar 29 '14 at 04:49

Generic static factory

2 Answers2