POO: Comprendre la surcharge et la redéfinition de méthode en Java
Tags: poo, java, surcharge, redefinition
Published: 2023-03-10 18:27:47

La programmation orientée objet repose sur le concept d'héritage, qui permet aux classes de dériver de classes existantes. L'héritage permet aux classes de partager des propriétés et des méthodes communes, tout en offrant la possibilité de personnaliser et d'ajouter des fonctionnalités spécifiques à chaque classe. Pour exploiter cette flexibilité et cette réutilisabilité, les développeurs ont recours à des concepts clés tels que la redéfinition de méthode, la surcharge et le polymorphisme.

### Redéfinition de méthode

La redéfinition de méthode, également appelée polymorphisme par substitution, se produit lorsque les sous-classes redéfinissent les méthodes héritées de leur classe parente. Cela permet aux sous-classes de personnaliser le comportement des méthodes héritées pour répondre à leurs propres besoins.

Prenons l'exemple d'une classe Voiture qui a une méthode "vitesseMaximale" :
```java
public class Voiture {

    public void vitesseMaximale() {
        System.out.println("Vitesse max voiture = 200 km/h");
    }

}
```
Maintenant, supposons que nous ayons une classe Enfant qui hérite de la classe Voiture et souhaite redéfinir la méthode "vitesseMaximale" pour sa propre utilisation :

```java
public class Enfant extends Voiture {

    @Override
    public void vitesseMaximale() {
        System.out.println("Vitesse max voiture enfant = 20 km/h");
    }

}
```
Dans cet exemple, la classe Enfant a redéfini la méthode "vitesseMaximale" héritée de la classe Voiture pour afficher une vitesse maximale différente pour les enfants. Lorsqu'un objet de la classe Enfant est créé et que la méthode "vitesseMaximale" est appelée, la méthode redéfinie dans la classe Enfant sera exécutée plutôt que la méthode de la classe Voiture.

### Surcharge de méthode

La surcharge de méthode se produit lorsqu'une classe a plusieurs méthodes avec le même nom, mais des paramètres différents. Cela permet à une classe de traiter différents types de données et de fournir une interface commune pour les méthodes qui ont des fonctionnalités similaires.

Prenons l'exemple d'une classe Voiture qui a une méthode "vitesseMaximale" surchargée pour accepter un argument de type String :
```java
public class Voiture {

    public void vitesseMaximale() {
        System.out.println("La vitesse maximale de la voiture est de 200 km/h");
    }
    
    public void vitesseMaximale(String conducteur) {
        System.out.println("La vitesse maximale de la voiture pour " + conducteur + " est de 250 km/h");
    }

}
```
Dans cet exemple, la classe Voiture a deux méthodes avec le même nom "vitesseMaximale", mais la deuxième méthode prend un argument de type String qui représente le nom du conducteur. Lorsqu'un objet de la classe Voiture est créé et que la méthode "vitesseMaximale" est appelée avec un argument, la méthode surchargée sera exécutée plutôt que la méthode originale qui ne prend pas d'argument.

### Polymorphisme

Le polymorphisme se réfère à la capacité des objets d'une classe à prendre plusieurs formes. En Java, le polymorphisme est réalisé grâce à la redéfinition de méthode et à l'utilisation d'une référence de type de classe parente pour faire référence à une classe fille.

Prenons l'exemple d'une classe Animal qui a une méthode "crier" :
```java
public class Animal {

    public void crier() {
        System.out.println("L'animal crie");
    }

}
```
Maintenant, supposons que nous ayons deux classes qui héritent de la classe Animal, la classe Chien et la classe Chat :
```java
public class Chien extends Animal {

    @Override
    public void crier() {
        System.out.println("Le chien aboie");
    }

}
```

```java
public class Chat extends Animal {

    @Override
    public void crier() {
        System.out.println("Le chat miaule");
    }

}
```
Dans cet exemple, les classes Chien et Chat ont redéfini la méthode "crier" héritée de la classe Animal pour représenter les sons qu'ils font. Maintenant, supposons que nous ayons une méthode "faireCrier" dans une autre classe qui prend un objet de la classe Animal en paramètre et appelle sa méthode "crier" :
```java
public class RefugedeAnimaux {

    public void faireCrier(Animal animal) {
        animal.crier();
    }

}
```
Maintenant, si nous créons un objet Chien et un objet Chat et appelons la méthode "faireCrier" sur chaque objet, la méthode "crier" correspondante de chaque objet sera exécutée :
```java
public static void main(String[] args) {

    RefugedeAnimaux refugedeAnimaux = new RefugedeAnimaux();
    Chien chien = new Chien();
    Chat chat = new Chat();
    
    refugedeAnimaux.faireCrier(chien); // affiche "Le chien aboie"
    refugedeAnimaux.faireCrier(chat); // affiche "Le chat miaule"

}
```
Dans cet exemple, l'utilisation de la référence de type de classe parente "Animal" nous permet d'appeler la méthode "crier" de la sous-classe appropriée en fonction de l'objet passé en paramètre.

### Conclusion

La redéfinition de méthode, la surcharge et le polymorphisme sont des concepts clés en programmation orientée objet en Java. Ces concepts permettent aux développeurs de créer des classes flexibles et réutilisables, en personnalisant le comportement des méthodes héritées, en permettant à une classe de traiter différents types de données et en permettant aux objets d'une classe de prendre plusieurs formes. J'espère que cet article a aidé à clarifier ces concepts en utilisant un exemple simple de la classe Voiture.