Newsgroup: it.comp.java
Titolo: generics e compatibilità con le versioni precedenti

Avevo letto (non ricordo bene dove) qualcosa sulle enum, che avevo
interpretato nel senso che l'uso dei generics non pregiudicava la
compatibilità del codice con le versioni precedenti di java.
Ho provato ad introdurre, a titolo di test, la riga "ArrayList<int[]>
test=new ArrayList(3);" in un programma 1.1.4 compatibile: se provo a
compilare con 1.2, mi dà (ovviamente) erori in compilazione. Se
compilo con 1.5, dando l'opzione -target 1.2, mi dice che il target
predefinito è 1.5, e si rifiuta di eseguire. Se compilo con 1.5
compila regolarmente, ma se tento di eseguire con 1.2 mi risponde che
non può eseguire una versione successiva con la precedente.
Avevo capito male io?
C'è modo di inserire i Generics mantenendo la compatibilità del
codice con le versioni precedenti di Java?

 Avevo capito male io?
In realtà avevo capito così anch'io.
Mi ricordo tutta uan lunga discussione all'uscita della 1.5 secondo cui i  
generics non erano stati introdotti ma simulati e che quindi non si  
trattava di vera innovazione.
In realtà non né ho la minima idea, anch'io ho riscontrato i tuoi  
problemi, ma mi sono semplicemente arreso ad aggiornare la jvm
-- 
Manny Calavera
Mail To: anforagimailpuntocom²

 problemi, ma mi sono semplicemente arreso ad aggiornare la jvm
Dunque, ho trovato questo:
http://forum.java.sun.com/thread.jspa?forumID=316&threadID=321534
In particolare nel frammento che riporto in calce, se non capisco male
l'inglese, uno degli sviluppatori di java Sun dice che la
compatibilità dei generics non c'è, e ciccia; se si usano, il codice
generato va eseguito con la JVM 1.5, anche se può interagire con altro
codice non contenente i generics e compilato con versioni precedenti
(ma da eseguire, evidentemente, con JVM 1.5). O ho capito male?
Yes. I am Sun's compiler team. I'm a small team.
Backward compatibility is the ability to use old sources and binaries
in newer versions of the JDK. We will continue to support that. What
you're describing is forward compatibility, which allows newer language
features to be run on old VMs. We can't support that in general because
new language features often require VM support. Nevertheless, generics
code will interoperate with old code run on the same (newer) VM.
We are adding a number of language features in the 1.5 timeframe
that will require platform support. Even generics will get some
platform
support in the released product, in the form of extended reflection
interfaces. In 1.4 we added assertions, and the generated code uses
features of the platform only available in 1.4. Therefore, if you
enable assertions you must have -target 1.4. Similarly in 1.5 we
are considering (among other things) enumeration types, which require
platform support.
In order to bring sanity to the language, we do not allow users to pick
and choose individual language features to enable and disable. You can
only select the language level you're writing for, and if you use a
feature that requires platform support at a certain level, you will
simply
have to use a target VM that has that level of support.
But I was wrong to abandon forward compatibility.
The way I implemented this constraint was incorrect. I caused -source
1.4
(or later) to imply -target 1.4 (or later), the logic being that if you
are
enabling new language features you will have to have VM support for
them.
But I really should only require a recent -target version if the
program
actually uses a language feature in a way that causes code to be
generated
that invokes new VM features. For example, if you set -source 1.5, but
happen
to use no assertions in your source, then you should be free to set
-target 1.1.
I think you'll find that fixing the immediate problem requires changing
just one line of class com.sun.tools.javac.v8.code.Source to get the
effect
you want. I have filed 4776214 against the compiler and hope to have it
fixed
(i.e. implemented properly, by depending on which language features you
actually
use) in a refresh of the prototype in a couple of months.
Sorry for the inconvenience.

 compatibilità dei generics non c'è, e ciccia.
...anche se nell'articolo che avevo letto, che ho ritrovato, si dice
esattamente il contrario:
Tre di questi costrutti (Generics, foreach e Autoboxing/Unboxing) sono
indirizzati a semplificare la gestione di Array e Collections. Un'altro
costrutto, le enumeration, fornisce un meccanismo standard per la
definizione di insiemi di oggetti. Infine, ma non meno importante, sono
stati introdotti metadati, import statico e metodi con numero variabile
di argomenti.
Curiosamente le nuove features non hanno richiesto alcun cambiamento
alla Virtual Machine: esse vengono implementate nel compilatore con un
meccanismo tipo espansione di macro, che produce bytecode compatibile
con la precedente versione della JVM. In secondo luogo, l'aggiunta di
questi sette nuovi costrutti ha richiesto una sola nuova keyword, la
parola "enum" che non può più essere utilizzata come identificatore
di metodo, classe o variabile.
http://www.mokabyte.it/2004/03/jdk1_5.htm