Principes

Polymorphisme se rapport au fait qu’une variable objet prenne différentes “formes” au cours de sa vie, c’est à dire qu’elle puisse référencer des instances de classes différentes.

MAIS sous condition :

• la variable est déclarée avec un type A
• on affecte à cette variable des instances de A ou de sous-classes de A

Hors ces conditions, le compilateur signalera une erreur ou bien il y aura un crash l’exécution.

class A {...}
class B extends A {...}
class C extends A {...}
A a; B b; C c;

a = new A(); // OK
a = new B(); // OK
a = new C(); // OK
b = new A(); // ERR. COMP.
b = new B(); // OK
b = new C(); // ERR. COMP.
c = new A(); // ERR. COMP.
c = new B(); // ERR. COMP.
c = new C(); // OK

Utilisation

<aside> ⚠️

Le polymorphisme n’a d’interet que si on l’utilise conjointement avec le principe de redéfinition

</aside>

class A {
	void print() {...}
}
class B extends A {
	void print() {...}
	void toto() {...}
}

A a1 = new A();
B b = new B();
A a2 = new B();
a1.print(); // OK COMPILE
a1.toto(); // ERR. COMP.
a2.toto(); // ERR. COMP.
b.toto(); // OK COMP.
a2.print(); // OK COMP.

<aside> ⚠️

Le compilateur ne regarde QUE le type de déclaration c’est à dire A

</aside>

Si on écrit le même code en C++, a2.print() appellerai quand même print de A. En effet, comme le C++ n’est pas interprété, tout est réglé lors de la compilation par rapport aux types de déclaration.

Cependant , il est possible d’avoir l’appel de méthode dynamique si on déclare celles-ci avec le mot clef virtual.

Complications

avec une hierarchies de classes

class A {
	void print(){...}
}
class B extends A {
	void print(){...}
}
class C extends B {
	// on ne redef. pas ici
}

A  a = new C();
a.print(); // appel la méthode de B car C ne voit que la méthode héritée de B.

Que se passe-t-il si dans B, on déclare print() private ?

C’est OK à la compilation car ‘a’ est déclaré type A qui contient print() MAIS ERR exec. car l’intance de C n’a pas accès à une méthode print()

Erreurs d’execution