T具有不兼容的范围-Java泛型

Question

I'm trying to learn generics through making a generic Card and Deck class which looks like this;

Card.java

package com.tn.deck;

public class Card<S extends Comparable<S>, R extends Comparable<R>> implements Comparable<Card<S, R>> {
    private S suit;
    private R rank;

    public Card(S suit, R rank) {
        this.suit = suit;
        this.rank = rank;
    }

    @Override
    public String toString() {
        return "Card{" +
                "suit=" + suit +
                ", rank=" + rank +
                '}';
    }

    @Override
    public int compareTo(Card<S, R> o) {
        return rank.compareTo(o.rank);
    }
}

Deck.java

package com.tn.deck;

import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;


public final class Deck<T extends Card> {
    private List<T> deck;

    public <S extends Comparable<S>, R extends Comparable<R>> Deck(int numberOfDecks, S[] suits, R[] ranks) {
        this.deck = initializeDecks(numberOfDecks, suits, ranks);
        shuffle();
    }


    private <S extends Comparable<S>, R extends Comparable<R>> List<T> initializeDecks(S[] suits, R[] ranks) {
        return Arrays.stream(suits)
                .flatMap(suit -> Arrays.stream(ranks).map(rank -> new Card<>(suit, rank)))
                .collect(Collectors.toList()); // === It complains here. ===
    }

    private <S extends Comparable<S>, R extends Comparable<R>> List<T> initializeDecks(int numberOfDecks, S[] suits, R[] ranks) {
        return IntStream.range(0, numberOfDecks)
                .mapToObj(i -> initializeDecks(suits, ranks))
                .flatMap(Collection::stream)
                .collect(Collectors.toList()); 
    }

    public void shuffle() {
        Collections.shuffle(deck);
    }

    @Override
    public String toString() {
        return "Deck{" +
                "deck=" + deck +
                '}';
    }
}

The error I get is

Error:(57, 25) java: incompatible types: inference variable T has incompatible bounds
    equality constraints: T
    lower bounds: com.tn.deck.Card<S,R>

It's probably just me not understanding generics, but I would really appreciate someone explaining to me what I'm doing wrong.

Answer 1

This happens because you're creating Card , but must return List<T> . And T may be any subtype of Card , not Card itself.

When you're working with a generic class and need to create a new instance of T (or whatever erased generic type), you should accept a factory which is able to do so. For example:

public <S extends Comparable<S>, R extends Comparable<R>> Deck(int numberOfDecks, S[] suits, R[] ranks, BiFunction<S, R, T> cardFactory) {
    this.deck = initializeDecks(numberOfDecks, suits, ranks, cardFactory);
    shuffle();
}


private <S extends Comparable<S>, R extends Comparable<R>> List<T> initializeDecks(S[] suits, R[] ranks, BiFunction<S, R, T> cardFactory) {
    return Arrays.stream(suits)
            .flatMap(suit -> Arrays.stream(ranks).map(rank -> cardFactory.apply(suit, rank)))
            .collect(Collectors.toList());
}

private <S extends Comparable<S>, R extends Comparable<R>> List<T> initializeDecks(int numberOfDecks, S[] suits, R[] ranks, BiFunction<S, R, T> cardFactory) {
    return IntStream.range(0, numberOfDecks)
            .mapToObj(i -> initializeDecks(suits, ranks, cardFactory))
            .flatMap(Collection::stream)
            .collect(Collectors.toList());
}

Answer 2

why this error occurs? the generic parameter T extends Card is all of the subclass of Card including itself is allowed here. when the generic parameter T is a subclass type of Card , then the error occurs where your code initializeDecks try to return a superclass instance without casting. let's see a simple concrete example:

class Superclass{}
class Subclass extends Superclass{}

Subclass sub= ...;
// you can assign subclass's instance to superclass since it is-a superclass
Superclass sup = sub;
// you can assign superclass's instance to subclass you need casting it down
Subclass sub2 = (Superclass) sup;

you can fix your code as below:

<S extends Comparable<S>, R extends Comparable<R>> 
        List<? super T> initializeDecks(...){ 
  ....
}

Answer 3

In the method that's getting the error, you are creating a bunch of Card<S, R> objects and then trying to put them into a List . In order for that to work, the List needs to be able to hold objects of that type.

A List<T> can hold an object if and only if the object's class is T or a subclass of T . So, for this line to work, Card<S, R> has to be a subclass of T . Now if you look at the constraints on T , what you specify is that T is a subclass of Card . This constraint does not guarantee the relationship that putting the cards in the list requires, so you get an error.