如果没有强制转换，则无法使用通用参数调用通用方法

Question

First of all, sorry for the title but even after minutes of thinking, this was best I found. Here the situation:

I have an abstract 'Factory' class. It takes T as return type of the instance.

abstract class Factory<T> {
    abstract T getInstance();
}

Now I add an interface to mark classes which have a factory. This interface is parameterized with the Factory itself.

interface Factorized<TFACTORY extends Factory<?>> {}

Now I can mark classes that have a factory.

class BaseImpl1 implements Factorized<BaseImpl1Factory> {}
class BaseImpl1Factory extends Factory<BaseImpl1> {
    @Override BaseImpl1 getInstance() { return null; /* TODO */}
}

With a small method and some reflection I can get an instance of the factory by passing the base class itself.

<RETURNED_FACTORY extends Factory<?>> RETURNED_FACTORY getFactory(Class<? extends Factorized<RETURNED_FACTORY>> clazz) {
    /* TODO */
}

// usage:
BaseImpl1Factory factory = getFactory(BaseImpl1.class);

This works fine until the point where I add generics in the base class .

See the full example:

public class Test {
    void test() {
        getFactory(BaseImpl1.class).someMethod1();
        getFactory(BaseImpl2.class).someMethod2();     // <-- compile error
        getFactory((Class<? extends Factorized<BaseImpl2Factory>>) BaseImpl2.class).someMethod2(); // <-- it works with cast
        getFactory(SubBase2Impl.class).someMethod2();  // only for info.. this works
    }

    <RETURNED_FACTORY extends Factory<?>> RETURNED_FACTORY getFactory(Class<? extends Factorized<RETURNED_FACTORY>> clazz) {
         /* TODO */
    }
}

abstract class Factory<T> {
    abstract T getInstance();
}
interface Factorized<TFACTORY extends Factory<?>> {}

// ****** implementation without generic *******
class BaseImpl1 implements Factorized<BaseImpl1Factory> {}
class BaseImpl1Factory extends Factory<BaseImpl1> {
    void someMethod1(){}
    @Override BaseImpl1 getInstance() { /* TODO */ }
}

// ****** implementation with generic *******
class BaseImpl2<T> implements Factorized<BaseImpl2Factory> {}
class BaseImpl2Factory extends Factory<BaseImpl2<?>> {
    void someMethod2(){}
    @Override BaseImpl2<?> getInstance() { /* TODO */ }
}

class SubBase2Impl extends BaseImpl2<String>{}

It works when I cast it but why do I have to? What do I have to change to access the factory without casting?

Hints:

• It is required to get the concrete instance BaseImpl1Factory and not only the abstract Factory instance when calling getFactory() because the factories have diffent methods and it should be needed to cast
• Please don't care about the probably stupid plan behind this. Actually the real problem is completely different but wanted to take out the business problem as much as possible

Answer 1

You're looking for what's called a self-type . Here's an example:

interface Factory<T> { T getInstance(); }

interface Buildable<T> { Factory<T> getFactory(); }

class CanBuild implements Buildable<CanBuild> {
  @Override
  public Factory<CanBuild> getFactory() {
    return null; // TODO
  }
}

The Buildable interface ( Factorized in your example) indicates a type that can build T s. While T could be any type, you'll often use it as a self-type by making T the same type as the class being defined.

Self-types are commonly used when defining fluent interfaces . The Truth library uses them heavily, so you might like to poke around their code to see more examples.