Polymorphisme en Java

Salut! Aujourd'hui, nous concluons une série de leçons sur les principes de la POO. Dans cette leçon, nous parlerons du polymorphisme Java. Le polymorphisme est la capacité de travailler avec plusieurs types comme s'il s'agissait du même type. De plus, le comportement des objets sera différent selon leur type. Examinons de plus près cette déclaration. Commençons par la première partie : 'la possibilité de travailler avec plusieurs types comme s'il s'agissait du même type'. Comment différents types peuvent-ils être identiques? Cela semble un peu étrange :/ En fait, tout est très simple. Par exemple, cette situation se produit lors de l'utilisation ordinaire de l'héritage. Voyons comment cela fonctionne. Supposons que nous ayons une simple classe parent Cat avec une seule méthode run() :

public class Cat {

   public void run() {
       System.out.println("Run!");
   }
}

Nous allons maintenant créer trois classes qui héritent de Cat : Lion , Tiger et Cheetah .

public class Lion extends Cat {

   @Override
   public void run() {
       System.out.println("Lion runs at 80 km/h");
   }
}

public class Tiger extends Cat {

   @Override
   public void run() {
       System.out.println("Tiger runs at 60 km/h");
   }
}

public class Cheetah extends Cat {

   @Override
   public void run() {
       System.out.println("Cheetah runs at up to 120 km/h");
   }
}

Nous avons donc 3 classes. Modélisons la situation où nous pouvons travailler avec eux comme s'ils étaient de la même classe. Imaginez que l'un de nos chats est malade et a besoin de l'aide du Dr Dolittle. Essayons de créer une classe Dolittle qui peut soigner les lions, les tigres et les guépards.

public class Dolittle {

   public void healLion(Lion lion) {

       System.out.println("Lion is healthy!");
   }

   public void healTiger(Tiger tiger) {

       System.out.println("Tiger is healthy!");
   }

   public void healCheetah(Cheetah cheetah) {

       System.out.println("Cheetah is healthy!");
   }
}

Il semble que le problème soit résolu : la classe est écrite et prête à fonctionner. Mais que ferons-nous si nous voulons étendre notre programme? Nous n'avons actuellement que 3 types : les lions, les tigres et les guépards. Mais il existe plus de 40 types de chats dans le monde. Imaginez ce qui se passerait si nous ajoutions des classes séparées pour les manuls, les jaguars, les Maine Coons, les chats domestiques et tout le reste. Le programme lui-même fonctionnera, bien sûr, mais nous devons constamment ajouter de nouvelles méthodes à la classe Dolittle pour soigner chaque type de chat. En conséquence, il atteindra des tailles sans précédent. C'est là qu'intervient le polymorphisme - "la capacité de travailler avec plusieurs types comme s'ils étaient du même type". Nous n'avons pas besoin de créer d'innombrables méthodes pour faire la même chose - soigner un chat. Une méthode suffit pour tous:

public class Dolittle {

   public void healCat(Cat cat) {

       System.out.println("The patient is healthy!");
   }
}

La méthode healCat() peut accepter les objets Lion , Tiger et Cheetah — ce sont toutes des instances de Cat :

public class Main {

   public static void main(String[] args) {

       Dolittle dolittle = new Dolittle();

       Lion simba = new Lion();
       Tiger shereKhan = new Tiger();
       Cheetah chester = new Cheetah();

       dolittle.healCat(simba);
       dolittle.healCat(shereKhan);
       dolittle.healCat(chester);
   }
}

Sortie console : Le patient est en bonne santé ! Le patient est en bonne santé ! Le patient est en bonne santé ! Alors notre Dolittleclass fonctionne avec différents types comme s'ils étaient du même type. Abordons maintenant la deuxième partie : "de plus, le comportement des objets sera différent selon leur type". Tout est très simple. Dans la nature, chaque chat court d'une manière différente. Au minimum, ils fonctionnent à des vitesses différentes. Parmi nos trois félins, le guépard est le plus rapide, tandis que le tigre et le lion courent moins vite. En d'autres termes, leur comportement est différent. Le polymorphisme fait plus que simplement nous laisser utiliser différents types comme un seul. Il nous permet également de nous souvenir de leurs différences, en préservant le comportement propre à chacun d'eux. L'exemple suivant illustre cela. Supposons que nos chats, après une récupération réussie, décident de profiter d'une petite course. Nous allons ajouter ceci à notre classe Dolittle :

public class Dolittle {

   public void healCat(Cat cat) {

       System.out.println("The patient is healthy!");
       cat.run();
   }
}

Essayons d'exécuter le même code pour traiter trois animaux :

public static void main(String[] args) {

   Dolittle dolittle = new Dolittle();

   Lion simba = new Lion();
   Tiger shereKhan = new Tiger();
   Cheetah chester = new Cheetah();

   dolittle.healCat(simba);
   dolittle.healCat(shereKhan);
   dolittle.healCat(chester);
}

Et voici à quoi ressemblent les résultats : Le patient est en bonne santé ! Lion court à 80 km/h. Le patient est en bonne santé ! Tiger court à 60 km/h. Le patient est en bonne santé ! Le guépard court jusqu'à 120 km/h Ici, nous voyons clairement que le comportement spécifique des objets est préservé, même si nous avons passé les trois animaux à la méthode après les avoir "généralisés" à Cat . En raison du polymorphisme, Java se souvient bien qu'il ne s'agit pas simplement de trois chats. Ce sont un lion, un tigre et un guépard, qui courent chacun différemment. Ceci illustre le principal avantage du polymorphisme : la flexibilité. Lorsque nous devons implémenter certaines fonctionnalités partagées par de nombreux types, les lions, les tigres et les guépards deviennent simplement des « chats ». Tous les animaux sont différents, mais dans certaines situations, un chat est un chat, quelle que soit son espèce :) Voici une vidéo de confirmation pour vous.

Lorsque cette "généralisation" n'est pas souhaitée et que nous avons plutôt besoin que chaque espèce se comporte différemment, chaque type fait sa propre chose. Grâce au polymorphisme, vous pouvez créer une interface unique (ensemble de méthodes) pour un large éventail de classes. Cela rend les programmes moins compliqués. Même si nous étendons le programme pour prendre en charge 40 types de chats, nous aurions toujours l'interface la plus simple : une seule méthode run() pour les 40 chats.