[JAVA] Domandina su JVM e polimorfismo

[D4rkAng3l]

Ciao...devo fare un esame che è diviso in un primo compito di teoria ed un secondo compto di Java...

Per la parte di teoria su un vecchio compito c'è questa domanda sulla JVM che non saprei bene come rispondere (ovvero visto che ho perso parte dei miei appunti non sò se c'è anche altro da dire).

La domanda è:

Descrivere i possibili binding calcolati dalla JVM nel corso dell'esecuzione di un'applicazione

Io direi così:

In Java c'è l'overloading degli operatori (operatori sovraccarichi) cioè esistono più versioni dello stesso operatore dipendentemente dal tipo di dati usati.
Per esempio per l'operatore di somma ci sarà un operatore + per valori interi ed un operatore + per valori double e così via:
+(int, int)
+(double, double)

Questo avviene per i tipi built in di Java, quando invece creo una nuova classe stò definendo un nuovo tipo di dati (ovvero la struttura dati e gli operatori necessari ad operare su di essa) ed in Java si usa la sola COMPATIBILITA' PER NOME ovvero che due differenti tipi definiti dall'utente non sono mai compatibili anche se avessero la stessa struttura (a differenza di altri linguaggi che adottano una compatibilità per struttura).
In Java opero sugli oggetti istanza di una classe solo con i metodi di tale classe e quindi 2 diversi tipi di dato non saranno mai compatibili perchè avranno ognuna i propri metodi.

Tutto questo ragionamento per passare al concetto di polimorfismo e da quà ai binding eseguiti dalla JVM.

Se per esempio ho una classe Rettangolo che mi istanzia oggetti che rappresentano dei rettangoli con i lati paralleli agli assi cartesiani:

public Rettangolo{
........
........
........
}

Se volessi avere poi una classe Quadrato che mi rappresenti quadrati avente i lati paralleli agli assi cartesiani potrei ottenerla estendendo la classe Rettangolo senza doverla riscrivere partendo da 0:

class Quadrato extendes Rettangolo{
........
........
........
}

nel cui codice ci metterei solo le differenze rispetto a quadrato tra cui il metodo costruttore ma vabbè non mi addentro oltre...in pratica ridefinisco solo tutti i metodi del supertipo che non si comporterebbero bene nel sottotipo.

A questo punto se nel main dichiaro una variabili Q come Rettangolo e poi lo costuisco come un quadrato:

Rettangolo R;
R = new Quadrato(P,4)

Posso farlo tranquillamente ma a questo punto anche se il tipo effettivo con cui ho creato l'oggetto è Quadrato per il compilatore è un Rettangolo perchè l'ho dichiarato tale...pertanto potrei usare solo i metodi della classe Rettangolo e non potrei usare qualche nuovo metodo definito solo nella classe Quadrato (come ad esempio un metodo per calcolare l'area del cerchio inscritto nel quadrato) e se chiamassi un metodo di quadrato su un oggetto di tale tipomi darebbe errore, tipo:

double y = R.ragioCerchioInscritto(); darebbe errore

Quindi R è una variabili polimorfica perchè può assumere vari tipi...e se in Java una variabile è polimorfica:

1) Deve essere un sottotipo del tipo con cui l'ho dichiarata
2) Posso usare solo operazioni del supertipo con cui l'ho dichiarata.

Questo perchè Java è un linguaggio fortemente tipizzato e posso usare la variabile solo con la forma con cui l'ho dichiarata ed i controlli li farà il compilatore garantendo così che il linguaggio sia strongly typed (cioè è garantito chenon ci saranno errori di tipo dopo la compilazione).

Ma nel main potrei avere anche una situazione di questo tipo:

[code]
.........
lanciaMoneta
if(TESTA) R = new Rettangolo(P,8,2);
else R = new Quadrato(P,4);
R.dilata;
}

A questo punto il compilatore non può sapere a priori se l'oggetto R sarà creato come Rettangolo o come Quadrato e non saprà se usare il metodo dilata() (che è stato modificato nella classe Quadrato rispetto alla versione definita nella classe Rettangolo) del sottotipo Quadrato o del supertipo Rettangolo.

Per risolvere questo problema il binding tra l'INVOCAZIONE DEI METODI ed il CORPO DEI METODI viene eseguito a runtime dalla JVM.

Si dice che JAVA è polimorficoper inclusione cioè che le diverse forme che una variabile può assumere sono solo i sottotipi di una classe...ed infatti per dichiarare un oggetto che può assumere qualsiasi forma lo devo dichiarare come Object che è la superclasse generele a tutte le classi.

C'è altro da dire? Sopratutto la JVM esegue altri tipi di binding durante l'esecuzione di un'applicazione (ho perso gli appunti della lezione successiva quindi booo)

Grazie
Andrea

[shinya]

Dire che in java il binding è dinamico e a single dispatch non basta?