[JAVA] Capire alcuni punti del JLS

[andbin]

Sto leggendo il JLS (Java Language Specification) e ci sono dei punti nella sezione §5.5 Casting Conversion (http://java.sun.com/docs/books/jls/third_edition/html/conversions.html#5.5) che non capisco. So che sono cose molto particolari e specifiche ma se qualcuno è in grado di spiegarle, ringrazio in anticipo.

Ad un certo punto dice:

A cast from a type S to a parameterized type (§4.5) T is unchecked unless at least one of the following conditions hold:

* S <: T.
* All of the type arguments (§4.5.1) of T are unbounded wildcards.
* T <: S and S has no subtype X≠T , such that the erasures (§4.6) of X and T are the same.

I primi due punti mi sono molto chiari, il terzo (evidenziato in rosso) no.

In pratica dice che il cast non è unchecked se la condizione è che: T è un sottotipo di S (quindi è un down-cast) e S non ha un sottotipo X diverso da T tale che le erasure di X e T sono le stesse. Cioè?? :mbe:

Solo con la prima parte (T <: S) un esempio sarebbe facile da fare:
class Super { }
class Sub<T> extends Super { }

Super sup = new Sub<String> ();
Sub<String> sub = (Sub<String>) sup;
Qui Super è S e Sub<String> è T ma il cast è unchecked. E in quale condizione non sarebbe unchecked?? Un esempio?


---------------------------
Altro punto, sempre in §5.5 un po' più sotto:

The detailed rules for compile-time legality of a casting conversion of a value of compile-time reference type S to a compile-time reference type T are as follows:

* If S is a class type:
* If T is a class type, then either |S| <: |T|, or |T| <: |S|; otherwise a compile-time error occurs. Furthermore, if there exists a supertype X of T, and a supertype Y of S, such that both X and Y are provably distinct parameterized types (§4.5), and that the erasures of X and Y are the same, a compile-time error occurs.

Anche qui la prima parte mi è chiara, S e T devono essere in "linea di ereditarietà" (String e Integer ad esempio non lo sono). La parte successiva (evidenziata in rosso) no, non mi è chiara. Anche qui un esempio sarebbe utile.

[lovaz]

Per il primo punto io capisco:
S non ha un sottotipo con la stessa erasure di T, esempio:
Set<String> e Set<Integer> sono tipi diversi, ma con uguale erasure (Set),
e se S è ad es. Object il cast sarà unchecked, perche' Object ha come
sottotipi
tutti i Set di tutti gli oggetti.
Se invece la conversione è "univoca" il cast è checked...

Prendi ad esempio il codice:

List<Integer> l = new ArrayList<Integer>();
ArrayList<Integer> al = (ArrayList<Integer>) l;

Non dà warning perché List<Integer> è supertipo di ArrayList<Integer>, e non
ad esempio di ArrayList<String>, che avrebbe la stessa erasure...

In conclusione direi che se S è parametrico il cast è checked, altrimenti è unchecked.

Non ti so dire di piu', il mio cervello si ferma qui :D

[lovaz]

Esempio per il secondo punto:
siano X = List<Integer> e Y = List<String> (tipi distinti, stessa erasure);
qualsiasi conversione tra un sottotipo di X e uno di Y fallisce.
Questo dice la frase in rosso.

Potrei aver detto un sacco di fregnacce, quindi non ti fidare troppo :sofico:

[andbin]

Intanto grazie per la risposta.

Non dà warning perché List<Integer> è supertipo di ArrayList<Integer>, e non
ad esempio di ArrayList<String>, che avrebbe la stessa erasure...

In conclusione direi che se S è parametrico il cast è checked, altrimenti è unchecked.La questione secondo me è diversa. Il testo dice: "A cast from a type S to a parameterized type T .....". Quindi T è certamente parametrizzato mentre S no, perché questo punto parla del fatto che un cast da un S non parametrizzato a un T parametrizzato è sempre unchecked tranne (ed è qui che sbucano le eccezioni) uno dei tre casi elencati.

Tu invece hai fatto l'esempio di S e T entrambi parametrizzati, quindi è un'altra cosa, deduco io.


Esempio per il secondo punto:
siano X = List<Integer> e Y = List<String> (tipi distinti, stessa erasure);
qualsiasi conversione tra un sottotipo di X e uno di Y fallisce.
Questo dice la frase in rosso.Ci devo ragionare un pochino ... non sono sicuro al 100% che sia quel caso (ma potrei anche sbagliarmi).

[lovaz]

... "A cast from a type S to a parameterized type T .....". Quindi T è certamente parametrizzato mentre S no...
... un cast da un S non parametrizzato...
S è un tipo, non dice esplicitamente "non parametrizzato", quindi potrebbe esserlo...
Come hai detto tu T è certamente parametrizzato, S no.

Naturalmente posso sbagliarmi, anche perché non si capisce perché
hanno usato quei giri di parole, ma l'unico caso che mi viene in mente è quello...

[andbin]

S è un tipo, non dice esplicitamente "non parametrizzato", quindi potrebbe esserlo...
Come hai detto tu T è certamente parametrizzato, S no.Non è per controbattere o sminuire la tua spiegazione ma io l'ho inteso diversamente.

Qui si parla di una "unchecked conversion", che per definizione (§5.1.9) è: "There is an unchecked conversion from the raw type (§4.8) G to any parameterized type of the form G<T1 ... Tn>"
Ci sono dei casi in cui appunto pur passando da un raw type a un parameterized type non è unchecked.

Un esempio del primo caso (S <: T) è:
class StringList extends ArrayList<String> { }

ArrayList<String> t1 = new StringList (); // non è unchecked

Un esempio del secondo caso (All of the type arguments of T are unbounded wildcards) è:
ArrayList<?> t2 = new ArrayList (); // non è unchecked

Come vedi sono entrambi da raw type a parameterized type ma non sono unchecked.

E poi c'è 'sto terzo caso ......

[lovaz]

In realtà questa (la prima che avevi postato, 3o paragrafo primo post)
è la definizione di cast unchecked, e non di unchecked conversion...