Polimorfismo in Java

[giapal]

Salve,
ho un dubbio su Java.
Supponiamo di avere il seguente programma:

class Base {
int f (Base x) {return 1;}
}

class D1 extends Base {
int f (D1 x) { return 2;}
}

class D2 extends D1{
}

public class Prova {
public static void main(String[] argv)
{
Base b = new D2();
D1 der1= new D1 ();
D2 der2= new D2 ();
System.out.println(b.f(der1));
}
}

Il risultato che si ottiene è 1, quindi vuol dire che è stata usata la f della classe base. Come mai viene usata quella e non quella di D1?

Lo stesso risultato si ottiene sostituendo l'ultima riga con:

System.out.println(der1.f(b));

Grazie

[^TiGeRShArK^]

....ma non mettere nessun costruttore o mettere un costruttore vuoto è equivalente?
no, perchp sembrerebbe che ti istanzi b come classe Base nonostante gli dici new D2()...
forse il problema è proprio nella mancanza dei costruttori... prova un pò ad aggiungerli e vedi ke succede....

[pequeno]

"....ma non mettere nessun costruttore o mettere un costruttore vuoto è equivalente?"

Si nel casto di costruttore no-arg, ossia senza argomenti, infatti viene richiamato direttamente il costruttore della classe padre.

Il "problema" sta nell'argomento, se chiami b.f(der1), l'argomento der1 è dello stesso tipo di Base percui viene sempre eseguito il metodo f della classe base; lo stesso vale per System.out.println(der1.f(b));

Per renderti l'idea sostituisci il parametro del metodo f in ogni classe con int ad esempio oppure scrivilo in modo che non accetti argomenti, vedi che viene richiamato il metodo della classe figlia D1.

[pequeno]

Ti faccio un esempio

class Base {

    public Base(){
        System.out.println("classe base");
    }

    public int f () {
        return 1;
    }
}

class D1 extends Base {

    public D1(){
        System.out.println("classe D1");
    }

    public int f () {
        return 2;
    }
}

class D2 extends D1{

    public D2(){
        System.out.println("classe D2");
    }
}

public class Prova {

    public static void main(String[] argv){
        Base b = new D2();

        System.out.println(b.f());
    }

}

Eseguendo il codice viene stampato a video il numero 2 poichè la classe D2 eredita direttamente il metodo f dalla classe D1.

[^TiGeRShArK^]

appunto...quello che intendevo io + o - !

[anx721]

Base b = new D2();

b è cichiarato cone un riferimento a un Base

Quando invochi un metodo:

b.f(der1)

il compilatore vede se c'è un metodo f nella classe di b, cioè Base. C'è tale metodo? Sì. Che parametro prende? un Base. L'argomento der1 è castabile a Base? si allora la chiamata diventa:

b.f( (Base) der1)

Questo a tempo di compilazione.

A tempo di esecuzione b punta effettivamente a un oggetto D2. D2 ha ereditato i due metodi f dalle superclassi, uno che prende un Base e uno che
prende un D1. Poichè l'argomento che riceve è un Base viene eseguito il primo. Il "problema" per così dire è che si tiene in conto del tipo effettivo degli oggetti su cui si invoca il metodo, non del tipo effettivo degli argomenti. Se passi un argomento castato al tipo base sarà eseguito il metodo che prende il tipo base.

Quel codice lo puoi interpretare in questo modo:

Codice PHP:

class Base {

}

class D1 extends Base {
    int f (D1 x) { return 2;}

    int f (Base x) {return 1;}
}

class D2 extends D1{

}

public class Prova {
    public static void main(String[] argv){
        D2 b = new D2();
        D1 der1= new D1 ();
        D2 der2= new D2 ();
        //l'argomento der1 è visto come un Base
        System.out.println(b.f( (Base)der1 ));
    }
} 


[giapal]

Grazie mille per l'aiuto. Siete stati gentilissimi.