Java >> Tutoriel Java >  >> Java

Polymorphisme Java | Définition | Types | Exemples

Java

Quelle est la définition du polymorphisme Java ?

Le polymorphisme signifie une forme multiple, dérivée de 2 mots grecs :le premier mot "poly" signifie plusieurs et un autre "morphs" signifie formes . Donc, avec l'utilisation du polymorphisme Java  peut faire sur un objet sous plusieurs formes.

Polymorphisme possible lorsque les classes sont liées entre elles par is-a Relationship (Héritage).

Avant de commencer, renseignez-vous sur l'héritage Java. Dans Héritage, on hérite d'une propriété d'une autre classe, où propriété signifie méthodes, variables, etc.

L'avantage du polymorphisme Java  est autorisé à utiliser ces méthodes Inherit et effectue une action différente avec moins d'effort sans affecter les anciens codes de classe et d'interface.

Le polymorphisme en Java est l'un des concepts piliers de la POO. Dans ce didacticiel, nous voyons déjà ce qu'est le polymorphisme, alors nous examinons maintenant les types d'exemples différents.

Exemples de polymorphisme Java

Venons-en aux pratiques pratiques, Nous avons un Animal classe avec un sound() méthode. Quelles sous-classes peuvent être pour la classe Animal ? Évidemment comme un objet réel comme - chien, chats, rats, canard, etc. animaux.

Comme nous savons que chaque animal a un son différent, les classes Chien, Chat, Canard auront leur propre implémentation des méthodes sound(). Voir l'exemple ci-dessous de polymorphisme Java et comment les méthodes individuelles peuvent changer sous de nombreuses formes avec des modèles uniformes.

class Animal {
    public void sound() {
        System.out.println("The animal makes a sound");
    }
}

class Dog extends Animal {
    public void sound() {
        System.out.println("Dog says: Bow Bow");
    }
}

class Cat extends Animal {
    public void sound() {
        System.out.println("Cat says: meow meow");
    }
}

class Duck extends Animal {
    public void sound() {
        System.out.println("Duck says: quack quack");
    }
}

public class PolymorphismExample {
    public static void main(String arg[]) {
        //Creating objects
        Animal animal = new Animal(); //Animal object
        Animal dog = new Dog(); //Dog object
        Animal cat = new Cat(); //Cat object
        Animal duck = new Duck(); // Duck object

        animal.sound();
        dog.sound();
        cat.sound();
        duck.sound();
    }
}

Sortie : L'animal fait du bruit
Le chien dit :Bow Bow
Le chat dit :miaou miaou
Le canard dit :coin-coin

Types de polymorphisme en Java

Le polymorphisme en Java a deux types, vous trouverez un nom différent dans de nombreux endroits.

  • Polymorphisme au moment de la compilation (liaison statique) :la surcharge de la méthode Java est un exemple de polymorphisme statique
  • Polymorphisme d'exécution (liaison dynamique) :le remplacement de la méthode Java est un exemple de polymorphisme dynamique.

Polymorphisme à la compilation

La surcharge de méthode Java est appelée Compile Time ou Static ou Compile time Polymorphism.

Nous avons un didacticiel de profondeur complet à ce sujet, suivez ce lien - Java Overloading tutorial

Regardez un exemple et codez pour l'instant.

public class MethodOverloading {
    static int add(int a, int b) {
        return a + b;
    }
 
    static int add(int a, int b, int c) {
        return a + b + c;
    }
    public static void main(String[] args) {
        System.out.println(MethodOverloading.add(2, 16));
        System.out.println(MethodOverloading.add(78, 1, 9));
    }
}

Sortie : 18
88

Polymorphisme d'exécution

Le remplacement des méthodes Java est appelé Runtime ou Dynamic Polymorphism.

Voici un tutoriel complet basé sur celui-ci, suivez le lien - Java Override Tutorial

Voyons l'exemple simple et le code.

//base class
class Employee {
    //method
    void salary() {
        System.out.println("All Employee Salary Range is 10-50k");
    }
}
 
//subclass
 
class Manager extends Employee{
    @Override
    void salary(){
        System.out.println("Manager Salary  is 40k");
    }
}
 
public class MethodOverriding {
 
    public static void main(String arg[]){
 
        // creating base (parent) class object
        Employee employee = new Employee();
        employee.salary();
 
        // creating sub (child) class object
        Employee employee1 = new Manager();
        employee1.salary();
 
    }
}

Sortie : La fourchette de salaire de tous les employés est de 10 à 50 000
Le salaire du directeur est de 40 000 

Faites des commentaires si des doutes, des suggestions et des exemples sont nécessaires pour ce didacticiel. Suivez le lien supérieur du tutoriel pour mieux comprendre et il existe de nombreuses règles pour réaliser le polymorphisme.


Balise Java