Java generische obere begrenzt Wildcard Fehler

Question

ich die folgenden Einrichtungen in meinem Domain-Modell hat:

class Point { 
    public String details; 

    public Point() { 
     details = "empty"; 
    } 

    public Point(String details) { 
     this.details = details; 
    } 
} 

class BasicPoint<X, Y> extends Point { 
    public X x; 
    public Y y; 

    public BasicPoint() {} 

    public BasicPoint(X x, Y y) { 
     this.x = x; 
     this.y = y; 
    } 
} 

class Collector<T> { 
    T elem; 

    public void collect(T elem) { 
     this.elem = elem; 
    } 
} 

Ich mag Operationen auf Daten anzuwenden und diese Daten als Punkt oder BasicPoint zurückkehren, wie oben erklärt, aber der Compiler mit dem folgenden Fehler beschweren obwohl OUT erstreckt Point:

class Operator<OUT extends Point> { 
    public Collector<OUT> operate(Collector<OUT> collector) { 

     // compile error, collect(OUT) cannot be applied to BasicPoint<Integer, Integer> 
     collector.collect(new BasicPoint<Integer, Integer>(1,2)); 

     return collector; 
    } 
} 

Main-Methode sollte wie folgt aussehen:

Collector<BasicPoint<Integer, Integer>> c = new Collector<>(); 
c = new Operator<BasicPoint<Integer, Integer>>().operate(c); 
System.out.println(c.elem.getClass() == new BasicPoint<Integer, Integer>().getClass()); 

Answer 1

Ihre Operator ist generische es kann nicht collect auf eine BasicPoint, nur OUT gelten.

abstract class Operator<OUT extends Point> { 
    abstract Collector <OUT> operate(Collector<OUT> collector); 
} 

Und ein BasicPointOperator enthält dann die tatsächliche Implementierung, die Sie wollen: Sie können Ihre Collector abstrakt machen

class BasicPointOperator extends Operator<BasicPoint<Integer, Integer>> { 

    @Override 
    Collector<BasicPoint<Integer, Integer>> operate(Collector<BasicPoint<Integer, Integer>> collector) { 
     collector.collect(new BasicPoint<Integer, Integer>(1,2)); 
     return collector; 
    } 
} 

oder PointOperator, die ein bisschen mehr Generika ist

class PointOperator extends Operator<Point> { 

    @Override 
    Collector<Point> operate(Collector<Point> collector) { 
     collector.collect(new BasicPoint<Integer, Integer>(1,2)); 
     return collector; 
    } 
} 

Answer 2

Das Problem ist, dass Sie die Dinge in nicht setzen können, wenn der Typ Parameter ist contravariant. Etwas wie das

public Collector<?> operate(Collector<? super Point> collector) { 
    collector.collect(new BasicPoint<Integer, Integer>(1,2)); 
    collector.collect(new Point()); 

    return collector; 
}