tipizzazione statica di JAVA

JAVA utilizza la tipizzazione statica per i tipi. 

Questo significa che il tipo di un oggetto viene controllato in fase di compilazione (compile-time) e non in fase di esecuzione (run-time). Questa implementazione tecnologica serve a rendere il linguaggio più robusto e ad evitare errori in fase di scrittura del codice che sarebbero evidenti solo in fase di esecuzione, però porta ad alcune apparenti incongruenze quando si scrive il codice. Consideriamo questo codice, due classi di cui una estende l'altra un una classe Principale dove eseguire il codice:

public class SuperClasse {}

public class SottoClasse extends SuperClasse {

       public void stampa() {

             System.out.println("SottoClasse");}}

public class Principale {

       public static void main(String[] args) {           

             SuperClasse sc = new SottoClasse();

             System.out.println(sc.getClass());

             sc.stampa();

       }

}

Questo codice non compila. Se invece si elimina la riga sc.stampa(); compila e restituisce :class SottoClasse

Come è possibile che una classe SottoClasse  non possa usare il metodo stampa() definito al suo interno? Il motivo è che il compilatore non sa che sc a run-time sarà un oggetto SottoClasse . Vede solo che è stato definito come oggetto SuperClasse e quindi non possiede il metodo stampa().

Se JAVA fosse un linguaggio a tipizzazione dinamica, dove cioè si assegna il tipo solo in fase di esecuzione il codice sopra andrebbe bene. Questo blocco è di sicurezza e quindi è tecnologico più che logico. Infatti se cambiamo il codice, in particolare la classe :

public class SuperClasse { public void stampa() {

       System.out.println("SuperClasse");}}

Adesso il codice compila, infatti SuperClasse possiede un metodo stampa() e il compilatore non brontola più. Se però facciamo girare il programma avremo questo risultato:

class SottoClasse

SottoClasse

Quindi abbiamo due fasi ben distinte:

in fase di compilazione il compilatore considera sc come un oggetto SuperClasse e quindi permette di usare il suo metodo stampa() che stampa SuperClasse .

in fase di esecuzione però ad sc viene assegnato un oggetto SottoClasse ,che ha un metodo stampa() che sovrascrive quello della SuperClasse . Quindi il risultato sarà la stampa di SottoClasse.