Polymorhisme ,Programmation Java

En Java, comme généralement, en P.O.O., une classe peut "redéfinir" (c’est-à-dire modifier)
certaines des méthodes héritées de sa classe de base. Cette possibilité est la clé de ce que l’on
nomme le "polymorphisme", c’est-à-dire la possibilité de traiter de la même manière des
objets de types différents, pour peu qu’ils soient issus de classes dérivées d’une même classe
de base. Plus précisément, on utilise chaque objet comme s’il était de cette classe de base,
mais son comportement effectif dépend de sa classe effective (dérivée de cette classe de
base), en particulier de la manière dont ses propres méthodes ont été redéfinies. Le polymor-
phisme permet d’ajouter de nouveaux objets dans un scénario préétabli et, éventuellement,
écrit avant d’avoir connaissance du type exact de ces objets.

Conseille : avant de commencer le cour de polymorphisme ,il vaut mieux de commencer par le cour d’héritage

Le polymorphisme est la capacité, pour un même message (méthode) de correspondre à plusieurs formes de traitements selon l'objet auquel ce message est adressé à l’exécution, lorsqu’une méthode d’un objet est accédée au travers d’une référence, c’est la méthode telle qu’elle est définie au niveau de la classe effective de l’objet qui est invoquée et exécutée.
La méthode à exécuter est déterminée à l’exécution et non pas à la compilation

public class Test {
    public static void main (String[] argv) {
        Point p = new Point(23,45);
        p.affiche();
        Pointcol pc = new Pointcol(5,5,(byte)12);
        p = pc;p.affiche();
        // appelle la méthode affiche de la classe Pointp = new Point(12,45);p.affiche();
        // appelle la méthode affiche de la classe Pointcol
        }
    }
    class Point {
            int x,y;
            public Point(){
                this.x = 0; this.y = 0;
                
            }
        public Point(int x, int y){
            this.x = x;
            this.y = y;
            
        }
        public void deplace(int dx, int dy) {
            x += dx; y+=dy; }
        public void affiche() {
            this.identifie();
            System.out.println("Je suis en "+ x + " " + y);
            
        }
    public void identifie() {
        System.out.println("Je suis un point");}}
    class Pointcol extends Point {
        private byte couleur;
        public Pointcol(int x, int y, byte couleur) {this.couleur=couleur;}
        public void affiche() {super.affiche();System.out.println("et ma couleur est : " + couleur); }
        public void identifie() {System.out.println("Je suis un point coloré");}
    }

Dans la dernière instruction, la variable p est de type Point, alors que l’objet référencé par p
est de type Pointcol. L’instruction p.affiche() appelle alors la méthode affiche de la classe
Pointcol. Autrement dit, elle se fonde, non pas sur le type de la variable p, mais bel et bien
sur le type effectif de l’objet référencé par p au moment de l’appel (ce type pouvant évoluer
au fil de l’exécution). Ce choix d’une méthode au moment de l’exécution (et non plus de la
compilation) porte généralement le nom de ligature dynamique (ou encore de liaison dyna-
mique).

En résumé, le polymorphisme en Java se traduit par :

• la compatibilité par affectation entre un type classe et un type ascendant,

• la ligature dynamique des méthodes.

Le polymorphisme permet d’obtenir un comportement adapté à chaque type d’objet, sans
avoir besoin de tester sa nature de quelque façon que ce soit. La richesse de cette technique
amène parfois à dire que l’instruction switch est à la P.O.O. ce que l’instruction goto est à la
programmation structurée. Autrement dit, le bon usage de la P.O.O (et du polymorphisme)
permet parfois d’éviter des instructions de test, de même que le bon usage de la programma-
tion structurée permettait d’éviter l’instruction goto.

Advertiser