Parametryzacja Dobrze ukształtowania i przechwytywania konwersji w Javie

Question

Biorąc pod uwagę dwa następujące definicje klasy:

class C1<T extends C1<T>> {} 

class C2<U> extends C1<C2<U>> {} 

I następującą deklarację typu:

C1<C2<?>> a; 

Intuicyjnie czuje deklarowany typ a powinien być ważny, ale to nie jest sposób w jaki zachowuje się JDK-8u45. Zamiast tego mamy coś jak poniżej:

Test.java:3: error: type argument C2<?> is not within bounds of type-variable T 
     C1<C2<?>> a; 
      ^
    where T is a type-variable: 
    T extends C1<T> declared in class C1 
1 error 

(Edit: byłem bycie Dingus tutaj, ta część została odpowiedział: C2<?>nie wykracza C1<C2<?>> Zagadnienie dotyczące deklaracji c poniżej. jest wciąż kwestią otwartą, choć.)

Ale C2<?>ma przedłużyć C1<C2<?>>, który wydaje się trywialnie zaspokoić związany. Badanie JLS nie zapewnia dalszego oświetlenia, o ile widzę. To naprawdę powinno być tak proste, jak spełnienie powiązania przez relację podtypu, ponieważ C2<?> nie jest typem wieloznacznym, a zatem konwersja przechwytywania jest tylko konwersją tożsamości dla argumentu.

Istnieją sytuacje, w których staje się nieco mniej oczywiste, na przykład podjąć następujące definicje klasy:

class C3<T extends C3<?>> {} 

class C4<Y, Z> extends C3<C4<Z, Y>> {} 

class C5<X extends C3<X>> { 
    void accept(X x); 
} 

Wszystko to jest w porządku, ale jeśli spróbujemy następującą deklarację:

C5<C6<?, ?>> b; 

Rzeczy stają się coraz dziwniejsze. C6<?, ?> jest podtypem C3<C6<?, ?>>, więc deklaracja powinna być ważna zgodnie z moją interpretacją specyfikacji podaną powyżej w odniesieniu do deklaracji C1<C2<?>>. Problem polega na tym, że wyraźnie nie każdy możliwy podtyp C6<?, ?> faktycznie spełnia to ograniczenie, więc teraz na przykład C5.accept() rozstrzyga typ jego parametru na C6<?, ?>, a więc może przyjmować argumenty, które naruszają granicę na X, tj. Gdziekolwiek, gdzie parametryzacje Y i Z nie są identyczny.

Gdzie ja się tu mylę? Czy moje rozumienie związku podtypów jest niewystarczające?

(Edit: Poniższa część pytania jest nadal bez odpowiedzi, ale ja przeniósł go do nowego pytania here ponieważ jest to zupełnie inna kwestia naprawdę ... Przepraszam za bałagan i nie korzystania z witryny bardzo dobrze haha ​​...)

Poza tym, mam również problemy z konwersją przechwytywania w podobnych sytuacjach. Podjąć następujące oświadczenie typu:

C1<? extends C2<?>> c; 

przeciwieństwie do podobnej deklaracji a na początku, to kompiluje grzywny w JDK-8u45. Jeśli jednak przeanalizujemy kod specification for capture conversion, to wydaje się, że ta deklaracja powinna spowodować, że w tym czasie wystąpi błąd czasu kompilacji.

W szczególności, górna granica nowego typu zmienna przechwytywania CAP#T określał glb(Bi, Ui[A1:=S1,...,An:=Sn]), gdzie w tym przypadku Bi postanawia wildcard związany C2<?> i Ui[A1:=S1,...,An:=Sn] postanawia C1<CAP#T>.

Z tego glb(C2<?>, C1<CAP#T>) postanawia typu przecięcia C2<?> & C1<CAP#T>, które jest nieważne, ponieważ C2<?> i C1<CAP#T> są oba typy klas, a nie interfejs typu, ale ani jedna z nich nie jest podtypem drugiej.

To (pozorne) naruszenie przepisów jest bardziej jasne w samym definition of the intersection type.

Jestem pewien, że to nie jest błąd i po prostu robię gdzieś proste błędy ... ale jeśli nikt tutaj nie może mi o tym powiedzieć, wypróbuję listę mailingową kompilatora lub coś podobnego.

Dzięki za pomoc!

Answer 1

Podczas
C2<x> extends C1<C2<x>> dla każdego typu referencyjnego x,
to nie jest tak, że
C2<?> extends C1<C2<?>>

Znak wieloznaczny ? jest nie rodzaj. Jest to argument typu . Składnia jest jednak bardzo zwodnicza (według projektu).

Użyjmy innej składni - jeśli istnieje jakiś symbol wieloznaczny pierwszego poziomu, użyj {} zamiast <>, np.

List{?}, Map{String, ? extends Number} 

Znaczenie {?} jest zadeklarować Union Typ

List{? extends Number} == union of List<Number>, List<Integer>, List<Long>, .... 

Łatwo zobaczyć, że List<Integer> jest podtypem List{? extends Number}; i
List{? extends Number} jest podtypem List{? extends Object}

Jednakże, nie ma mowy, że Foo{?} jest podtypem z Foo<x>.

---

W naszej składni <> jest zarezerwowana dla zastępując typ vars z typów. Tak więc piszemy
List<String>, C2<Integer> itp. Łatwo jest zrozumieć ich znaczenie - wystarczy zastąpić T z String w kodzie źródłowym List, otrzymujemy starą klasę zwykłą.

interface List<String> 
     String get(int) 

To nie może być zrobione dla zamiennika - nie ma sensu

interface List<?> 
     ? get(int) 

Więc to nie może new ArrayList{?}() lub class MyList implements List{?}

Tak, jak możemy wykorzystać List{?}?Jakie metody możemy do niego zastosować?

Gdy type ekspresji jest List{?}, wiemy, że jest to obiekt, a obiekt musi należeć do podklasy List<x> jakiegoś nieznanego typux. To jest przechwytywanie wieloznaczny

obj is a List{?} => obj is a List<x>, where x a subtype of Object. 

Choć dokładny typ x jest znany w czasie kompilacji, możemy jeszcze zrobić substytucji

interface List<x> 
     x get(int) 

więc możemy zrozumieć sens rozmowy obj.get(0); zwraca x, a x jest podtypem Object; więc możemy przypisać wartość zwracaną do Object.