Расширение шаблона объекта Java Generics [дубликат]

Следующие будут работать нормально:

public List<? extends Foo> getFoos() {
    List<Foo> foos = new ArrayList<Foo>();
    foos.add(new SubFoo());
    return foos;
}

Просто подумал, что я бы добавил к этому старому потоку, суммируя свойства параметров List, созданных с помощью типов или подстановочных знаков ....

Когда у метода есть параметр / результат, который является List, использование типа экземпляра или подстановочных знаков определяет

1. Типы списка, которые могут быть переданы методу в качестве аргумента
2. Типы списка, которые могут быть заполнены из результата метода
3. Типы элементов, которые могут быть записаны в список в методе
4. Типы, которые могут быть заполнены при чтении элементов из списка в методе

Param / Тип возврата: List< Foo>

1. Типы списка, которые могут быть переданы методу в качестве аргумента: List< Foo>
2. Типы списка, которые могут быть заполнены из Результат метода: List< Foo> List< ? super Foo> List< ? super SubFoo> List< ? extends Foo> List< ? extends SuperFoo>
3. Типы элементов, которые могут быть записаны в список в пределах метода: Foo & amp; подтипы
4. Типы, которые могут быть заполнены при чтении элементов из списка в методе: Foo & amp; супертипы (до Object)

Параметр / Тип возврата: List< ? extends Foo>

1. Типы списка, которые могут быть переданы методу в качестве аргумента : List< Foo> List< Subfoo> List< SubSubFoo> List< ? extends Foo> List< ? extends SubFoo> List< ? extends SubSubFoo>
2. Типы списка, которые могут быть заполнены из результата метода: List< ? extends Foo> List< ? extends SuperFoo> List< ? extends SuperSuperFoo>
3. Типы элементов, которые могут быть записаны для перечисления в методе: Нет! Невозможно добавить.
4. Типы, которые могут быть заполнены при чтении элементов из списка в методе: Foo & amp; супертипы (до Object)

Параметр / Тип возврата: List<? super Foo>

1. Типы списка, которые могут быть переданы методу в качестве аргумента : List< Foo> List< Superfoo> List< SuperSuperFoo> List< ? super Foo> List< ? super SuperFoo> List< ? super SuperSuperFoo>
2. Типы списка, которые могут быть заполнены из результата метода: List< ? super Foo> List< ? super SubFoo> List< ? super SubSubFoo>
3. Типы элементов, которые могут быть записаны для перечисления в рамках метода: Foo & amp; супертипы
4. Типы, которые могут быть заполнены при чтении элементов из списка в методе: Foo & amp; супертипы (до Object)

Интерпретация / комментарий

• потребности внешних вызывающих абонентов приводят дизайн декларации метода, т.е. публичный API (обычно первичное рассмотрение)
• потребности в логике внутреннего логического устройства приводят любые дополнительные решения к фактическим типам данных, объявленным и построенным внутренне (обычно вторичное рассмотрение)
• используют List<Foo>, если код вызывающего абонента всегда сфокусирован при манипулировании классом Foo, поскольку он максимизирует гибкость как для чтения, так и для записи
• , используйте List<? extends UpperMostFoo>, если может быть много разных типов абонентов, ориентированных на управление другим классом (не всегда Foo), и есть один самый верхний класс в иерархии типов Foo, и если этот метод предназначен для внутренней записи в список, а чтение списка вызывающих абонентов читается. Здесь метод может внутренне использовать List< UpperMostFoo> и добавлять к нему элементы, прежде чем возвращать List< ? extends UpperMostFoo>
• , если может быть много разных типов вызывающих, сфокусированных на управлении другим классом (не всегда Foo), и если чтение и запись в список требуется, и в иерархии типов Foo есть один самый низкий класс, тогда имеет смысл использовать List< ? super LowerMostFoo>

Попробуйте:

public List<Foo> getFoos() {
    List<Foo> foos = new ArrayList<Foo>();
    foos.add(new SubFoo());
    return foos;
}

Генерирующий конструктор ArrayList должен иметь определенный тип для параметризации, вы не можете использовать '?' wildcard там. Изменение экземпляра «new ArrayList & lt; Foo & gt; ()» разрешило бы первую ошибку компиляции.

Объявление переменной foos может иметь подстановочные знаки, но поскольку вы знаете точный тип, он делает больше чтобы ссылаться на информацию о том же типе. Что вы теперь говорите, что foos содержит определенный подтип Foo, но мы не знаем, что. Добавление SubFoo может быть запрещено, поскольку SubFoo не является «всеми подтипами Foo», Изменение декларации в «List & lt; Foo & gt; foos =» решает вторую ошибку компиляции.

Наконец, я бы изменил тип возвращаемого значения на «List & lt; Foo & gt;»; поскольку клиенты этого метода не смогут многое сделать с возвращаемым значением, как определено в настоящее время. Вы должны редко использовать подстановочные знаки в типах возврата. При необходимости используйте сигнатуру с параметризованным методом, но предпочитайте ограниченные типы только в аргументах метода, так как который оставляет его до вызывающего абонента, который может передавать конкретные типы и работать и соответственно.

Чтобы понять, как работают дженерики, посмотрите этот пример:

    List<SubFoo> sfoo = new ArrayList<SubFoo>();
    List<Foo> foo;
    List<? extends Foo> tmp;

    tmp = sfoo;
    foo = (List<Foo>) tmp;

Дело в том, что это не было предназначено для локальных / членных переменных, а для сигнатур функций, вот почему это так осел в обратном направлении.