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

Question

У меня есть необщий код вроде этого:

class List { 
    List intersect(List out, List other) { 
    if (out == null) out = new List(); 
    // insert elements common to $this and $other into $out 
    return out; 
    } 
} 

Этого метода безопасно использовать смешанные типы содержащихся объектов:

1. other может содержат объекты более конкретного типа (подкласс)
2. out может содержать объекты менее определенного типа (суперкласс)

. (А не от реального кода)

List<Number> my; 
List<Integer> other; 
List<Object> result = new(); 

result = my.intersect(result, other); 

Что мне нужно, поэтому:

class List<T> { 
    <R super T> List<R> intersect(List<R> out, List<? extends T> other); 
} 

Однако это не компилируется. В FAQ Generics указано, что нижняя граница для параметра типа не имеет смысла, но я не вижу этого приведенного выше примера.

Ближайший я получаю:

List<? super T> intersect(List<? super T> out, List<? extends T> other); 

Но это требует явного приведения возвращаемого значения на месте вызова.

Можно ли создать этот метод таким образом, чтобы он был безопасным для всех существующих обычаев?

UPDATE: В случае это не очевидно: (., Который является интерфейсом кстати) это не java.util.List но пользовательский класс. Исключительные части были опущены, но подпись метода точно такая же, как показано (за исключением уровня доступа).

UPDATE2: По типу безопасности я имею в виду как можно более ограниченные возможности. В идеале все параметры должны соблюдать оба правила, изложенные выше.

Answer 1

Вы пытаетесь нарушить правила ковариации и контравариантности. Предположим, вы ожидаете List<Object> в качестве вашего out параметра, а T - некоторый класс A, и есть еще один класс B, который расширяет A. Разработчик вашего intersect метода создает List<A> для out, что кажется прекрасным, поскольку A расширяет B. Но вызывающий получает список, который он предполагает, что он является List<Object>. Теперь вызывающий пытается вставить кучу C (не связанную с A и B, за исключением того, что все три происходят из объекта в какой-то момент), и все это взрывается.

Другими словами, это невозможно.

Answer 2

Редактировать: Так как я полностью неправильно понял вопрос, вот новая попытка ответить.

Я сначала хотел ответить

class List<T> { 
     /** 
     * Creates the intersection of this list with a second list, 
     * adding the resulting elements to another list. 
     * @param out the List to which the output should be added. 
     *  If null, a new List will be created. 
     * @param second the second list to intersect with this list. 
     * @return out, with the intersection of left an right added 
     */ 
    <R super T, S extends R> 
     List<R> intersect(List<R> out, List<S> second); 
} 

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

(Я знаю, что вы сказали, что S должен быть подтипом T, а не только S, но я по-прежнему не вижу этого по мере необходимости. На самом деле S может быть чем угодно, но оставляя его подтипом R дает больше свободы для реализации это действительно не имеет значения здесь)

Интересно, можно сформулировать как статический метод:..

class List<T> { 
     /** 
     * Creates the intersection of two Lists, 
     * adding the resulting elements to another list. 
     * @param out the List to which the output should be added. 
     *  If null, a new List will be created. 
     * @param left the first list to intersect. 
     * @param right the second list to intersect 
     * @return out, with the intersection of left an right added 
     */ 
    static <R, T extends R, S extends R> 
     List<R> intersect(List<R> out, List<T> left, List<S> right) { 
     // TODO 
     return out; 
    } 
} 

Или, если вам не нужен T и S внутри метода:

class List<T> { 
     /** 
     * Creates the intersection of two Lists, 
     * adding the resulting elements to another list. 
     * @param out the List to which the output should be added. 
     *  If null, a new List will be created. 
     * @param left the first list to intersect. 
     * @param right the second list to intersect 
     * @return out, with the intersection of left an right added 
     */ 
    static <R> 
     List<R> intersect(List<R> out, List<? extends R> left, List<? extends R> right) { 
     // TODO 
     return out; 
    } 
} 

Конечно, этот статический способ сказать это не работает, если вы хотите переопределить этот метод в подклассах.

Answer 3

<R> List<R> intersect(List<R> out, List<? extends R> other) 
{ 
    for(R x : other) 
     if(this.contains(x)) 
      out.add(x); 
    return out; 
} 

boolean contains(Object x){ ... } 

обратите внимание, что contains() принимает Object, вместо T