
Dans le chapitre précédent, nous avons parlé de super classes et de sous-classes. Si une classe hérite d'une méthode de sa super classe, il est possible de redéfinir la méthode à condition qu'elle ne soit pas définie comme étant final.
Le bénéfice de la substitution est: la capacité de définir un comportement spécifique au type de sous-classe, ce qui signifie qu'une sous-classe peut implémenter une méthode de classe parent basée sur ses besoins.
En termes axés sur l'objet, des moyens primordiaux pour redéfinir la fonctionnalité d'une méthode existante.
Exemple:
Examinons un exemple.
class Animal{
public void move(){
System.out.println("Animals can move");
}
}
class Dog extends Animal{
public void move(){
System.out.println("Dogs can walk and run");
}
}
public class TestDog{
public static void main(String args[]){
Animal a = new Animal(); // Animal reference and object
Animal b = new Dog(); // Animal reference but Dog object
a.move();// runs the method in Animal class
b.move();//Runs the method in Dog class
}
}
Cela produirait le résultat suivant:
Animals can move
Dogs can walk and run
Dans l'exemple ci-dessus, vous pouvez voir que même si b est un type d'Animal, il exécute la méthode move() dans la classe Dog. La raison en est: en temps de compilation, la vérification est effectuée sur le type de référence. Cependant, dans le temps d'exécution, JVM détermine le type d'objet et exécute la méthode qui appartient à cet objet particulier.
Par conséquent, dans l'exemple ci-dessus, le programme va se compiler correctement puisque la classe Animal a la méthode move(). Ensuite, au moment de l'exécution, il exécute la méthode spécifique pour cet objet.
Considérons l’exemple suivant :
class Animal{
public void move(){
System.out.println("Animals can move");
}
}
class Dog extends Animal{
public void move(){
System.out.println("Dogs can walk and run");
}
public void bark(){
System.out.println("Dogs can bark");
}
}
public class TestDog{
public static void main(String args[]){
Animal a = new Animal(); // Animal reference and object
Animal b = new Dog(); // Animal reference but Dog object
a.move();// runs the method in Animal class
b.move();//Runs the method in Dog class
b.bark();
}
}
TestDog.java:30: cannot find symbol
symbol : method bark()
location: class Animal
b.bark();
^
Ce programme lancera une erreur de temps de compilation puisque le type de référence de b Animal n'a pas de méthode bark().
En invoquant une version de superclasse d'une méthode surchargée, le mot clé super est utilisé.
class Animal{
public void move(){
System.out.println("Animals can move");
}
}
class Dog extends Animal{
public void move(){
super.move(); // invokes the super class method
System.out.println("Dogs can walk and run");
}
}
public class TestDog{
public static void main(String args[]){
Animal b = new Dog(); // Animal reference but Dog object
b.move(); //Runs the method in Dog class
}
}
Cela produirait le résultat suivant:
Animals can move
Dogs can walk and run