Java-Typ Inferenz in Builder-Muster

Question

Ich möchte eine parametrisierte (generische) Klasse MyType<T> und seine Erbauer erstellen. Der Builder verfügt über einige Methoden, die den Typ T und einige Methoden, die den Typ verwenden, ignorieren. aber es scheint, wie mit diesem Muster Ich habe die T Erklärung wiederholen:

     how to omit this declaration? 
            | 
            V 
MyType<String> myType = Builder.<String>of() 
           .method1(argument_can_be_of_any_type) 
           .method2(argument_must_be_of_type_T = String) 
           .build(); 

ist es möglich, einige Java-Syntax Tricks oder andere Design-Muster zu verwenden, um die zweite Typdeklaration zu verzichten und die API benutzerfreundlicher machen? wie zum Beispiel:

List<String> aList = Lists.emptyList(); 

oder

List<String> aList = new LinkedList<>(); 

ich will keine Reihenfolge von Methoden im Builder erzwingen

Answer 1

Ich habe Dinge überarbeitet ein wenig, da meine ursprüngliche Antwort didn‘ t arbeiten wie angekündigt. (Dank shmosel das Problem für das Auffinden und Daniel Pryden für die vorgeschlagene Lösung.)

/* contents of Box.java */ 
public class Box<T> 
{ 
    private T contents; 
    private Object data; 

    protected Box(T contents, Object data) { 
     this.contents = contents; 
     this.data = data; 
    } 

    public static BoxBuilder builder() { 
     return new BoxBuilder(); 
    } 

    public T getContents() { 
     return contents; 
    } 
} 

/* contents of BoxBuilder.java */ 
public class BoxBuilder 
{ 
    private Object data; 

    public BoxBuilder withAnything(Object o) { 
     this.data = o; 
     return this; 
    } 

    // Infers new type from argument 
    public <T> TypedBoxBuilder<T> withBoxContent(T contents) { 
     TypedBoxBuilder<T> builder = new TypedBoxBuilder<T>(); 
     builder.setData(data); 
     builder.setContents(contents); 

     return builder; 
    } 
} 

/* contents of TypedBoxBuilder.java */ 
public class TypedBoxBuilder<T> 
{ 
    private T contents; 
    private Object data; 

    public TypedBoxBuilder() { 
    } 

    public TypedBoxBuilder<T> withAnything(Object data) { 
     this.data = data; 
     return this; 
    } 

    public TypedBoxBuilder<T> withContents(T contents) { 
     this.contents = contents; 
     return this; 
    } 

    public Box<T> build() { 
     return new Box<T>(contents, data); 
    } 

    public void setContents(T contents) { 
     this.contents = contents; 
    } 

    public void setData(Object data) { 
     this.data = data; 
    } 
} 

Und hier ist der Client-Code:

Box<String> box = Box.builder() // Returns BoxBuilder 
     .withBoxContent("FOO") // Returns TypedBoxBuilder<String> 
     .withAnything(42) // Returns TypedBoxBuilder<String> 
     .build(); // Returns Box<String> 
String c = box.getContents(); 

Und das funktioniert auch:

Box<String> box = Box.builder() // Returns BoxBuilder 
     .withAnything(42) // Returns BoxBuilder 
     .withBoxContent("FOO") // Returns TypedBoxBuilder<String> 
     .build(); // Returns Box<String> 
String c = box.getContents();