Héritage et polymorphisme

Version imprimable

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
    class Alpha
    {
         public void afficher(double d)
         {
              System.out.println("renvoyer double de alpha : " + d);
         }

    }

    class Beta extends Alpha
    {

    }

    class Gamma extends Alpha
    {
         public void afficher(long l)
         {
              System.out.println("renvoyer long de gamma : " + l);
         }
    }

    class Delta extends Gamma
    {
         public void afficher(int i)
         {
              System.out.println("renvoyer int de delta : " + i);
         }
    }

    class Omega extends Gamma
    {
         public void afficher(float f)
         {
             System.out.println("renvoyer float de omega : " + f);
         }

         public void afficher(int i)
{
              System.out.println("renvoyer int de omega : " + i);
         }
    }




public class TesterSurdefinitionETpolymorphisme

    {
         public static void main(String [] args)
         {
             byte b = 1; short s = 5; int i = 22; long l = 44;
            float f = 2.5f; double d = 33.01;

              Alpha a = new Alpha();
              a.afficher(b);
              a.afficher(f);
              System.out.println();

                a.afficher(b);
            a.afficher(f);
            System.out.println();

            Gamma g = new Gamma();
            g.afficher(b);
            g.afficher(l);
            g.afficher(f);

       a = g; 
   a.afficher(b);
    a.afficher(l);
    a.afficher(f);
            System.out.println();

    a = g;       
           a.afficher(b);
           a.afficher(l);
           a.afficher(d);
            System.out.println();

            Omega o = new Omega();
            o.afficher(b);
            o.afficher(i);
            o.afficher(f);
            o.afficher(d);

       //     a = 0;
         a.afficher(b);
         a.afficher(i);
         a.afficher(f);
         a.afficher(d);

            g = o;
            g.afficher(b);
            g.afficher(i);
            g.afficher(f);
            g.afficher(d);
        }
   }

Bonjour à tous,

Je n'arrive pas à comprendre un point dans le polymorphisme. J'ai mis en gras une ligne dans le code ci-dessus, si quelqu'un pourrait t-il m'expliquer le comportement ?

Le résultat obtenu est (les 3 instructions après la ligne en gras):

Citation:

renvoyer double de alpha : 1.0
renvoyer double de alpha : 44.0
renvoyer double de alpha : 33.01

D'avance, je vous remercie de m'aider à la compréhension de toutes les subtilités.

05/01/2011, 22h08
fahmi.bedoui

a = g

surclassement : a est une référence de la classe Alpha donc qui peut référer a un objet issue d'une classe compatible a la classe Alpha cad soit un objet issue de Alpha soit issue d'une sous classe de Alpha
dans ce cas Gamma est une sous classe de Alpha donc c'est un surclassement
c'est l'interet du polymorphisme qui permet a une référence a de référere a tout objet sous classé de la classe de a grace au lien dynamique qui permettaient au coiurs de l'exécution de déterminer le type réel de l'objet pour exécuter la méthode appropriée dans le cas de la redéfinition mais a condition que la méthode appelée figure dans la classe type de la référence ( classe de a )

dans votre cas je vois que les deux méthodes afficher (float f) et afficher (long l) ne figurent pas dans la classe Alpha donc je crois que ça sera une erreur a l'exécution
05/01/2011, 22h21
tchize_
vous déclarez toujours à votre compilateur que vous allez utiliser un "Alpha" (peu importe sa classe réelle) via la déclaration Alpha a;

en conséquence, quand vous dites à votre compilateur
Code:

1 2 3 4 a = g; a.afficher(b); a.afficher(l); a.afficher(f);
il l'interprète comme ceci:
Code:

1 2 3 a.afficher((Double)b); a.afficher((Double)l); a.afficher((Double)f);
car c'est la seule méthode déclarée dans alpha qui corresponde à vos critères.
Ensuite, a l'éxecution, la jvm cherchera dans Gamma (la classe réelle) après la méthode afficher(Double) à utiliser. Et ne la trouvera que dans la classe parent alpha. Vos autres méthodes n'ont rien a voir dans l'équation, ce ne sont pas les même signatures. Ceci aurai bien entendu donné un résultat différent:
Code:

1 2 3 g.afficher(b); g.afficher(l); g.afficher(f);
car Gamma possède plusieurs méthodes "afficher" avec des signature différentes et le compilateur devra choisir la plsu adaptée en fonction des types passés en paramètres.
06/01/2011, 11h32
replicator

Merci

L'explication est très clair :-)

Merci :)