Полезный пример с супер и безвестностью с расширением в Generics?

Ответ 1

Пример суперграничного

Введенный метод transferTo() принимает Cage<? super T> - клетку, которая содержит суперкласс из T. Поскольку T является экземпляром его суперкласса, то ОК, чтобы положить T в Cage<? super T>.

public static class Cage<T extends Animal> { 
    private Set<T> pen = new HashSet<T>();

    public void add(T animal) {
        pen.add(animal);
    }

    /* It OK to put subclasses into a cage of super class */
    public void transferTo(Cage<? super T> cage) {
        cage.pen.addAll(this.pen);
    }

    public void showAnimals() {
        System.out.println(pen);
    }
}

Теперь посмотрим <? super T> в действии:

public static class Animal {
    public String toString() {
        return getClass().getSimpleName();
    }
}
public static class Rat extends Animal {}
public static class Lion extends Animal {}
public static class Cage<T extends Animal> { /* above */ }

public static void main(String[] args) {
    Cage<Animal> animals = new Cage<Animal>();
    Cage<Lion> lions = new Cage<Lion>();
    animals.add(new Rat()); // OK to put a Rat into a Cage<Animal> 
    lions.add(new Lion());
    lions.transferTo(animals); // invoke the super generic method
    animals.showAnimals();
}

Вывод:

[Rat, Lion]

Другая важная концепция заключается в том, что, хотя верно, что:

Lion instanceof Animal // true

неверно, что

Cage<Lion> instanceof Cage<Animal> // false

Это не так, этот код будет компилироваться:

Cage<Animal> animals;
Cage<Lion> lions;
animals = lions; // This assignment is not allowed
animals.add(rat); // If this executed, we'd have a Rat in a Cage<Lion>

Ответ 2

Вы можете добавить Крыса в клетку <Rat> (конечно).

Вы можете добавить Крыса в клетку < Животное > , потому что Крыса "является" Животным (расширяет Животное).

Вы не можете добавить Крыса в клетку <? расширяет Animal > , потому что <? extends Animal > может быть <Lion> , который не является крысой.

Другими словами:

Cage<? extends Animal> cageA = new Cage<Lion>(); //perfectly correct, but:
cageA.add(new Rat());  // is not, the cage is not guaranteed to be an Animal or Rat cage. 
                       // It might as well be a lion cage (as it is).
                       // This is the same example as in Kaj answer, but the reason is not
                       // that a concrete Cage<Lion> is assigned. This is something, the
                       // compiler might not know at compile time. It is just that 
                       // <? extends Animal> cannot guarantee that it is a Cage<Rat> and 
                       // NOT a Cage<Lion>
//You cannot:
Cage<Animal> cageB = new Cage<Rat>(); //because a "rat cage" is not an "animal cage".
                                      //This is where java generics depart from reality.
//But you can:
Cage<Animal> cageC = new Cage<Animal>();
cageC.add(new Rat());  // Because a Rat is an animal.

Представьте, что у вас есть клетка <? extends Animal > , созданный абстрактным методом factory, который реализуется подклассом. В вашем абстрактном базовом классе вы не можете определить, какой тип на самом деле назначен, и компилятор не может, потому что, возможно, конкретный класс загружается только во время выполнения.

Это означает, что компилятор не может полагаться на Cage <? расширяет Animal > , чтобы не быть клеткой какого-либо другого конкретного подтипа, что сделало бы присвоение другого подтипа ошибке.

Ответ 3

Оба ответа до сих пор были замечательными. Я просто хотел бы добавить лакомый кусочек, чтобы помочь вам понять их.

Чтобы ответить Рон, вы можете подумать следующее:

"почему он someCage.add(rat1) становится Cage<? extends Animal>.add(rat1)? Не может ли какой-либо элемент Cage указать какой-либо клетке любого типа, который расширяет Animal (и теперь я указал, что он указывает на клетку крыс?)"

Полностью законный вопрос. Дело в том, что когда вы делаете someCage = ratCage, поэтапная копия выполняется из ratCage в someCage. Поэтому на самом деле вы не просто установили someCage, чтобы теперь указать на ratCage. На самом деле someCage по-прежнему является Cage<? extends Animal>. Вы не можете сделать someCage.add(rat1), потому что вы не знаете тип клетки, только тот тип, который был ограничен выше, Animal.

P.S.: Вы не можете добавить что-либо к someCage, так как его тип неизвестен

Ответ 4

Думаю, на ваш вопрос может ответить следующий фрагмент кода:

Cage<? extends Animal> cage = new Cage<Lion>();
cage.add(rat1);  

Вы можете ясно видеть, что приведенный выше код не может быть действительным, поскольку вы знаете, что клетка в настоящий момент является клеткой льва, и вам не следует добавлять крысу в клетку льва.

Компилятор не имеет того значения, которое вы присвоили клетке, поэтому он не может разрешить cage.add(rat1), даже если вы назначили клетку крысы клетке.