返回Builder的工厂方法不使用泛型进行编译。 怎么了？

Question

I'm trying to build an API, where a client can register a listener, which receives events. The listener method that is called upon an event takes an argument. The API should let the client decide if this argument should be an instance of the concrete class, or an instance of an interface (to avoid unnecessary castings in client listener implementations). To do this I have played around with generics. It works ok, except for one case!

The client implements an interface (see example in MyListener1Impl.java and MyListener2Impl.java) and can with generics decide the argument type of the event.

A static factory method is used to retrieve an instance of ClassABuilder.java. The ClassABuilder's build() method returns an instance of ClassA.java

For some reason it does not compile, when a Factory method is used together with the Builder Pattern (calling the methods in telescoping form) and when the concrete listener implementation is used as the generic type argument (see where variable "c4" is set). Can anyone tell me why? What is wrong?

See full example code below. Copy/paste below classes into Eclipse (or any other IDE) and you'll see where it does not compile.

class Main.java

public class Main{
    public static void main(String[] args){
        // Works ok when generic type argument is set to interface "AnyFile".
        // MyListener2Impl has also declared "AnyFile"
        ClassABuilder<AnyFile> builder0 = Factory.newClassABuilder();
        builder0.set(new MyListener2Impl());
        ClassA<AnyFile> c0 = builder0.build();

        // Also Works ok when methods are called in telescope form 
        // (not sure "telescope" is the correct term?) 
        ClassA<AnyFile> c1 = Factory.newClassABuilder()
        .set(new MyListener2Impl())
        .build();

        // Works ok when generic type argument is set to concrete "MyFileImpl".
        // MyListener1Impl has also declared "MyFileImple"
        ClassABuilder<MyFileImpl> builder2 = Factory.newClassABuilder();
        builder2.set(new MyListener1Impl());
        ClassA<MyFileImpl> c2 = builder2.build();
        // also works ok with telescop form, but Factory class is NOT used.
        ClassA<MyFileImpl> c3 = new ClassABuilder<MyFileImpl>().set(new MyListener1Impl()).build();

        // But with static factory method AND telescope style, it does not compile! Why? What is wrong?
        ClassA<MyFileImpl> c4 = Factory.newClassABuilder()
        .set(new MyListener1Impl())
        .build();
    }
}

class AnyFile.java

import java.util.List;
public interface AnyFile {
    List<AnyFile> listFiles();
}

class ClassA.java

public class ClassA <T extends AnyFile>{
}

class ClassABuilder.java

public class ClassABuilder <T extends AnyFile>{
    public ClassABuilder<T> set(Listener<T> a){
        return this;
    }

    public ClassA<T> build(){
        return new ClassA<T>();
    }
}

class Factory.java

public class Factory {
    public static <T extends AnyFile> ClassABuilder<T> newClassABuilder(){
        return new ClassABuilder<T>();
    }
}

class Listener.java

public interface Listener <T extends AnyFile>{
    void event(T file);
}

class MyFileImpl.java

import java.util.List;
public class MyFileImpl implements AnyFile{
    @Override
    public List<AnyFile> listFiles() {
        // do something...
        return null;
    }
}

class MyListener1Impl.java

public class MyListener1Impl implements Listener<MyFileImpl>{
    @Override
    public void event(MyFileImpl file) {
        // do something
    }
}

class MyListener1Impl.java

public class MyListener2Impl implements Listener<AnyFile>{
    @Override
    public void event(AnyFile file) {
        // do something
    }
}

Answer 1

The short answer is that Java's type inference isn't powerful enough to infer left-to-right. That is, the type <T> of Factory.newClassABuilder() (which will be used to parameterize ClassA ) must be known before the .set() method can be called, and Java cannot infer Factory.newClassABuilder() 's return type from the argument of a method called on that return type.

This kind of inference requires whole-program analysis, which few languages do, and Java definitely does not support.