Java Generics and Inheritance (specific issue)

Question

I would like to have an inheritance of generic classes and interfaces. There is one issue I cannot understand. The problem is reflected in the following simplified code:

public interface A1 <T extends F1<?>> {
    public void compare(T f1, T f2);
}

public class F1 < T extends A1<? extends F1<T>> >
{
    T a;
    public void compare(F1<T> f) {
        a.compare(this, f);
    }
}

A1 is in A1.java, F1 is in F1.java.

I get the compile-time error:

The method compare(capture#1-of ? extends F1<T>, capture#1-of ? extends F1<T>) 
in the type A1<capture#1-of ? extends F1<T>> is not applicable for the 
arguments (F1<T>, F1<T>)

I need A1 < ? extends F1< T>> for classes subclassing F1.

Additional information (after editing):

I would like to have 2 hierarchies ("O" instead of "F", "C" instead of "A"):

• The first hierarchy of classes (O1, O2 ...) contains all relevant information of the object as well as the "comparator" (any function which analyses a pair of 2 objects of the same type). The class of the object defines the type of the comparator which it accepts, and the main requirement is that the comparator should accept 2 object of the type of the hosting object. For example, O1 can only accept all the comparators which compare O1's, O2 can have comparators that accept O2's.
• The second hierarchy of classes is comparators (C1, C2...) themselves. they compare objects from the hierarchy 1.

Each element in both hierarchies adds supplementary functionality which is leveraged in subclasses.

Let's consider the following use case, one of the paths through these hierarchies:

• O1 has 2 members (not types!): val (any type), cmp (of type C1 which only accepts O1).
• C1_1 does not have a corresponding object O, but it implements additional functionality related to collections. It can compare objects ("basic" types like int, String, TColor and "complex" objects O's) in the collection and apply the aggregator which returns only 1 value (e.g. maximum). If the collection is of basic types, cmp2 is utilized to compare elements within the collection. For complex objects in collections, their integrated comparators are utilized.
• C1_1_1 implements how to compare lists of objects (1:1). C1_1_2 (not presented) can be used to compare sets of objects, e.g. with the cross product.
• O1_1 has val of the type TVALB which extend List<TVALA> and the comparator C1_1_1.

Other subclasses of C1_1_1/2 can have more refined implementations for comparing basic and complex objects.

The supporting code:

public abstract class O1 <TVAL, TC extends C1<? extends O1<TVAL>>>
{
    TVAL val;
    TC cmp;
    public double compare(O1<TVAL, TC> o) {
        return cmp.compare(this, o);
    }
}
public interface C1 <TO extends O1<?, ?> > {
    public double compare(TO t1, TO t2) {
      // ...
    }
}

public abstract class C1_1 <
        TVALA,
        TVALB extends Collection<TVALA>,
        TO extends O1<TVALB, ?>
    >
    extends C1 <TO> {

    Cmp2<TVALA, Double> cmp2;
    IAggregator<TVALA> aggr;

    Double compare(TO o1, TO o2) {
        return aggr.apply(
            compPairs(o1.val, o2.val, cmp2)
        );
    }

    abstract pairs<TVALA> compPairs(
        TVALB b1
        , TVALB b2
        , Cmp2<TVALA> cmp2);

    // aggregation
    public static class Aggr1<TVALA> implements IAggregator<TVALA> {
        public Double apply(pairs<TVALA> pairs) {
            //...
        }
    }
    public static class Aggr2<TVALA> implements IAggregator<TVALA> {
        // ...
    }
}

public abstract class C1_1_1 <
        TVALA,
        TVALB extends List<TVALA>,
        TO extends O1<TVALB, ?>
    >
    extends C1_1 <TO> {
    pairs<TVALA> compPairs(
            TVALB b1
            , TVALB b2
            , Cmp2<TVALA> cmp2) {
        // ...
    }
}

public abstract class O1_1 <
    TVALA extends O1<?,?>,
    TVALB extends List<TVALA>
    , TC extends C1_1_1<TVALA, TVALB, ? extends O1_1<TVALA, TVALB, TC>>>
    extends O1<TVAL>
{
    // ...
}

I use dependency injection to assign comparators (C-tree to objects O) in the specific class. Therefore, this approach (if it is feasible) can give the possibility to have a flexibility in choosing the proper comparator for specific types of objects.

Answer 1

Let's first rename the type variables because the two T's stand for different things, and hopefully it makes things clearer:

public interface A1 <T extends F1<?>> {
    public void compare(T t1, T t2);
}

public class F1 < S extends A1<T extends F1<S>> >
{
    S s;
    public void compare(F1<S> f) {
        s.compare(this, f);
    }
}

Now you see that you are actually calling compare on s, which is an instance of A1<T>, where T can be a subclass of F1<S>. The parameters you are passing however have type F1<S> and not the subclass T, which is pretty much what the compiler is saying.

Essentially you made the method parameters covariant, when maybe they should be contravariant. For that, use super instead of extends:

public class F1 < S extends A1<? super F1<S>> >
{
    S s;
    public void compare(F1<S> f) {
        s.compare(this, f);
    }
}

Answer 2

The problem is that a is of type A1<? extends F1<T>>, i.e. parameterised by a wildcard. You cannot then call A1<?>.compare, because the compiler doesn't know what specific type ? stands for.

You'd see the same behaviour for this much simpler code:

A1<? extends Object> a = ...;
a.compare(new Object(), new Object());

---

If I understand your use-case correctly, you just want to be able to parameterise F1 on specific comparators. So it seems like you should just be able to do this:

interface A1<A extends A1<A>> {
    public void compare(F1<A> f1, F1<A> f2);
}

class F1<A extends A1<A>> implements Comparable<F1<A>> {
    A a;
    @Override
    public void compareTo(F1<A> f) {
        a.compare(this, f);
    }
}

Note that I've made F1 implement Comparable, because that's good practice.

Answer 3

You can remove your A1 class and just use Comparable interface.

public class F1<T extends Comparable<T>> implements Comparable<F1<T>> {
    T t;

    @Override public int compareTo(F1<T> other){
        return t.compareTo(other.t);
    }
}