T extends Vergleichbar<T>

Habe ich die folgende Klasse.

class MyClass<T>

Verwendet er den folgenden Konstruktor.

MyClass(Comparator<T> comparator, Collection<? extends T> data)

Und es hat ein Feld, welches sich in den Konstruktor wie folgt:

this.data = Collections.unmodifiableCollection(data);

In dem speziellen Fall, in dem T implementiert Vergleichbar, ich will nicht verlangen, dass ein comparator übergeben werden, da kann ich einfach die Natürliche bestellen. Also dachte ich, ich sollte in der Lage sein verwenden Sie diesen Konstruktor:

public <T extends Comparable<T>> MyClass(Collection<T> data)

Aber es ist anscheinend ein " type mismatch: cannot convert from Collection<T> to Collection<? extends T> in der abtretungserklärung über. Ich habe alle möglichen Dinge versucht: das hinzufügen von weiteren generischen Parameter, und so weiter, aber keine funktioniert. Ich scheine nicht in der Lage, um anzugeben, ein gebunden, das sagt: wenn Sie einen Typ T, die Vergleichbar sind, machen die einfache Sache.

Irgendwelche Ideen?

Dank.

Ich nehme an, dass Sie wollen, deklarieren Sie Sie als eine zweite Konstruktor, richtig? So ändern MyClass<T> zu MyClass<T extends Comparable<T>> ist nicht eine option?
das ist richtig.
Ich finde, dass ich tun kann dieser über eine statische factory-Methode: statische <V erweitert Vergleichbar<V>> MyClass<V> getInstance(Sammlung<? erstreckt sich V> data), dies ist aber etwas unbefriedigend.
(Hinweis: der Letzte code-Beispiel werden zwei generische Parameter aufgerufen T - auf die Klasse und auf der Konstruktor (wie auf einer Methode, die nur sehr selten nützlich).

InformationsquelleAutor dgorur | 2011-10-25

generics java

Leider denke ich nicht, dass diese Art von "wenn-Vergleichbar ist dies anderes zu tun, dass" die Logik ist möglich, mit dem Java-Typ-system.

Könnte man split Vergleichbaren und nicht-Vergleichbaren Fällen in getrennten Klassen und verstecken Sie hinter einer Schnittstelle, so etwas wie dieses:

interface Interface<T> {
    public void processData();
}

class MyClass<T> implements Interface<T> {
    private final Collection<? extends T> data;
    MyClass(Comparator<T> comparator, Collection<? extends T> data) {
        this.data = data;
    }
    public void processData() {
        //...
    }
}

class MyCompClass<T extends Comparable<T>> implements Interface<T> {
    private final Collection<? extends T> data;
    MyCompClass(Collection<? extends T> data) {
        this.data = data;
    }
    public void processData() {
        //...
    }
}

class Factory {
    static <T extends Comparable<T>> Interface<T> create(Collection<? extends T> data) {
        return new MyCompClass<T>(data);
    }
    static <T> Interface<T> create(Comparator<T> comparator, Collection<? extends T> data) {
        return new MyClass<T>(comparator, data);
    }
}

Aber dies kann dazu führen, eine Menge duplizierten code. Eine weitere option ist das verlassen MyClass erfordern einen Komparator in seinem Konstruktor, und bauen, dass der Komparator in der Fabrik:

class MyClass<T> {
    private final Collection<? extends T> data;
    MyClass(Comparator<T> comparator, Collection<? extends T> data) {
        this.data = data;
    }
    public void processData() {
        //...
    }
}

class Factory {
    static <T extends Comparable<T>> MyClass<T> create(Collection<? extends T> data) {
        return new MyClass<T>(new Comparator<T>() {
            public int compare(T o1, T o2) {
                return o1.compareTo(o2);
            }
        }, data);
    }
    static <T> MyClass<T> create(Comparator<T> comparator, Collection<? extends T> data) {
        return new MyClass<T>(comparator, data);
    }
}

Deine zweite Lösung ist genau das, was ich am Ende machen. Vielen Dank für die Klarstellung, dass das, was ich tun wollte, ist in der Tat nicht möglich mit Java-Typ-system.
Sie können auch die Fabrik-Methode innerhalb MyClass

InformationsquelleAutor Chris B

0

Ich schließe dies scheint unmöglich zu sein, als die einfache Lösung
```
class MyClass<T> {

    Collection<? extends T> data;

    public MyClass(Comparator<T> comparator, Collection<? extends T> data) {
        this.data = data;
    }

    public <E extends T & Comparable<T>> MyClass(Collection<E> data) {
        this.data = data;
    }

}
```
abgelehnt wird vom compiler mit

Kann nicht geben Sie alle zusätzlichen gebundenen Comparable<T> wenn die erste gebunden ist, ist ein Typ-parameter

Siehe auch Warum kann ich nicht mit einem argument type in type-parameter mit mehrfach-Grenzen? (insbesondere Chris Povirk Antwort).

Als für die Lösungen, ich Stimme mit Chris B.

InformationsquelleAutor meriton - on strike

Können Sie über den normalen Konstruktor für den ersten Fall und eine factory-Methode für den zweiten:

class MyClass<T> {

    Collection<? extends T> data;
    Comparator<? super T> comparator;

    public MyClass(Comparator<? super T> comparator, Collection<? extends T> data) {
        this.data = data;
        this.comparator = comparator;
    }

    public static <T extends Comparable<? super T>> MyClass<T> fromComparable(Collection<T> data) {
        return new MyClass<T>(Collections.reverseOrder(Collections.reverseOrder()), data);
    }

}

InformationsquelleAutor newacct

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.