Pause café #111. Polymorphisme et liaison dynamique en Java. Boucle For en Java + exemple de syntaxe de boucle forEach

Polymorphisme et liaison dynamique en Java

Source : DZone Le polymorphisme est l'un des concepts fondamentaux de la programmation orientée objet. Que vous soyez nouveau dans la programmation Java ou développeur chevronné, vous devez savoir ce qu'est le polymorphisme et comment il fonctionne. La plupart des développeurs prétendent bien connaître ce sujet, mais lorsqu'il s'agit d'autres fonctionnalités complexes telles que la liaison statique et dynamique, beaucoup d'entre eux perdent confiance.

Qu’est-ce que le polymorphisme en Java ?

Le polymorphisme signifie avoir plusieurs formes. En programmation, cela fait référence à la capacité d’un signal ou d’un message à apparaître sous plusieurs formes.

Exemple concret

Une personne peut présenter plusieurs caractéristiques à la fois. Par exemple, une mère peut être simultanément une épouse, une fille, une sœur, une employée d’une entreprise, etc. Par conséquent, une personne peut présenter des caractéristiques différentes dans des conditions différentes. C'est ce qu'on appelle le polymorphisme.

L'importance du polymorphisme

Le polymorphisme est l'une des caractéristiques les plus importantes de tout langage de programmation orienté objet (par exemple Java). Grâce au polymorphisme, la même tâche peut être réalisée de différentes manières.

Types de polymorphisme

En Java, le polymorphisme peut être divisé en deux catégories :

1. Polymorphisme au moment de la compilation (liaison statique)
2. Polymorphisme d'exécution (Runtime, liaison dynamique)

Polymorphisme au moment de la compilation

Le polymorphisme au moment de la compilation est également connu sous le nom de liaison statique. Ce type de polymorphisme peut être obtenu par surcharge de fonctions ou d'opérateurs. Mais en Java, cela est limité à la surcharge de fonctions puisque Java ne prend pas en charge la surcharge d'opérateurs. Surcharge de fonctions Lorsqu'il existe au moins deux fonctions ou méthodes avec le même nom de fonction, mais que soit le nombre de paramètres qu'elles contiennent est différent, soit qu'au moins un type de données du paramètre correspondant est différent (ou les deux), alors cela est appelé fonction. ou surcharge de méthode, et ces fonctions sont appelées fonctions surchargées. Exemple 1 Jusqu'à présent, nous avons étudié ce qu'est la surcharge de fonctions. Essayons maintenant de démontrer la surcharge des fonctions logicielles.

class Main {

    // Method 1
    // Method with 2 integer parameters
    static int Addition(int a, int b)
    {

        // Returns sum of integer numbers
        return a + b;
    }
    // Method 2
    // having the same name but with 2 double parameters
    static double Addition(double a, double b)
    {
        // Returns sum of double numbers
        return a + b;
    }
    public static void main(String args[]) {

        // Calling method by passing
        // input as in arguments
        System.out.println(Addition(12, 14));
        System.out.println(Addition(15.2, 16.1));

    }
}

Vous pouvez exécuter le programme ci-dessus ici . Explication du programme :

• Le programme ci-dessus se compose de deux fonctions statiques portant les mêmes noms : Addition .

• Ici, les deux fonctions contiennent le même nombre de paramètres, mais leurs paramètres correspondants sont différents.

• La méthode 1 accepte deux paramètres entiers, tandis que la méthode 2 accepte deux paramètres doubles .

• À partir de la fonction principale, nous appelons d'abord la fonction Addition(12, 14) . Les paramètres passés sont des entiers (12 et 14), donc la méthode 1 sera appelée ici.

• Ensuite, nous avons appelé la fonction Addition(15.2, 16.1) . Puisque les paramètres passés sont de type de données double (15.2 et 16.1), la méthode 2 sera appelée cette fois .

• C'est ainsi que la surcharge de fonctions est réalisée en Java en fonction de différents types de données de paramètres.

Exemple 2 Considérons le programme ci-dessous :

class Main {

    // Method 1
    // Method with 2 integer parameters
    static int Addition(int a, int b)
    {

        // Returns sum of integer numbers
        return a + b;
    }

    // Method 2
    // having the same name but with 3 integer parameters
    static double Addition(double a, double b)
    {

        // Returns sum of integer numbers
        return a + b;
    }
    public static void main(String args[]) {

        // Calling method by passing
        // input as in arguments
        System.out.println(Addition(12, 14));
        System.out.println(Addition(15.2, 16.1));

    }
}

Vous pouvez exécuter le programme ci-dessus ici . Explication du programme :

• Le programme ci-dessus se compose de deux fonctions statiques portant les mêmes noms : Addition .

• Ici, les deux fonctions contiennent un nombre différent de paramètres, mais le type de données des deux premiers paramètres correspondants est le même (entier).

• La méthode 1 prend deux paramètres entiers et la méthode 2 prend trois paramètres de type de données entiers.

• À partir de la fonction principale, nous appelons d'abord la fonction Addition(2, 3) . Puisque les paramètres transmis sont des entiers (2 et 3), ils appelleront ici la méthode 1 .

• Ensuite, nous avons appelé la fonction Addition(4, 5, 6) . Les paramètres transmis sont des types de données doubles (4, 5, 6), ils appelleront donc la méthode 2 cette fois .

• C'est ainsi que les fonctions sont surchargées en Java en fonction d'un nombre différent de paramètres.

Exemple 3

class Main {

    // Method 1
    // Method with 2 integer parameters
    static int Addition(int a, int b)
    {
        // Return the sum
        return a + b;
    }
    // Method 2
    // having the same name but with 3 parameters
    // 1st parameter is of type double and other parameters
    // are of type integer
    static double Addition(double a, int b,  int c)
    {
        // Return the sum
        return a + b + c;
    }
    public static void main(String args[]) {

        // Calling method by passing
        // input as in arguments
        System.out.println(Addition(2, 4));
        System.out.println(Addition(4.2, 6, 10));

    }
}

Vous pouvez exécuter le programme ci-dessus ici . Explication du programme :

• Le programme ci-dessus se compose de deux fonctions statiques portant les mêmes noms : Addition .

• Les deux fonctions contiennent un nombre différent de paramètres et le type de données du premier élément correspondant est également différent.

• La méthode 1 prend deux paramètres entiers, tandis que la méthode 2 prend trois paramètres : le premier est de type double et les deux autres sont des types de données entiers.

• À partir de la fonction principale, nous appelons d'abord la fonction Addition(2, 4) . Puisque les paramètres transmis sont des entiers (2 et 4), ils appelleront ici la méthode 1 .

• Ensuite, nous avons appelé la fonction Addition(4.2, 6, 10) . Le premier paramètre passé est de type entier et les paramètres restants sont de type de données double (4.2, 6, 10), donc la méthode 2 sera appelée cette fois .

• C'est ainsi que Java réalise une surcharge de fonctions en fonction de différents nombres de paramètres ainsi que de différents types de données des paramètres correspondants.

Note. Une fonction ne peut pas être surchargée uniquement en fonction du type de retour de la fonction.

Polymorphisme d'exécution

Cette option est également connue sous le nom de liaison dynamique. Dans ce processus, l'appel d'une fonction créée pour une autre fonction n'est autorisé qu'au moment de l'exécution. Nous pouvons réaliser une liaison dynamique en Java en utilisant le remplacement de méthode.

Remplacement de méthode

Le remplacement de méthode en Java se produit lorsqu'une méthode dans une classe de base a une définition dans une classe dérivée. Une méthode ou une fonction de classe de base est appelée une méthode remplacée.

// Class 1
class Parent {

    // Print method
    void Print()
    {

        // Print statement
        System.out.println("Inside Parent Class");
    }
}

// Class 2
class Child1 extends Parent {

    // Print method
    void Print() { System.out.println("Inside Child1 Class"); }
}

// Class 3
class Child2 extends Parent {

    // Print method
    void Print()
    {
        // Print statement
        System.out.println("Inside Child2 Class");
    }
}

class Main {

    public static void main(String args[]) {

        // Creating an object of class Parent
        Parent parent = new Parent();
        parent.Print();

        // Calling print methods
        parent = new Child1();
        parent.Print();

        parent = new Child2();
        parent.Print();
    }
}

Vous pouvez exécuter le programme ci-dessus ici . Explication du programme :

• Le programme ci-dessus se compose de trois classes : Parent ( classe 1 ), Child1 ( classe 2 ) et Child2 ( classe 3 ). Les classes 2 et 3 héritent de la classe 1 .

• Parent a une méthode appelée Print() . À l'intérieur de cette fonction, nous imprimons " Inside Parent Class ". Child1 et Child2 ont également des fonctions Print() , qui remplacent essentiellement la fonction Print() de la classe Parent et impriment respectivement " Inside Child1 Class " et " Inside Child2 Class " sur la console.

• A partir de la fonction principale, nous créons d'abord un objet de la classe parent appelé parent. Nous utilisons ensuite cet objet pour appeler la méthode print de la classe parent . Par conséquent " Inside Parent Class " sera imprimé sur la console.

• Après cela, nous appelons le constructeur par défaut de la classe Child1 et appelons la fonction Print() . Notez que la méthode Print() définie dans la classe Child1 sera désormais appelée car nous avons remplacé la méthode Print() de la classe parent . Par conséquent, « Inside Child1 Class » sera imprimé sur la console.

• Enfin, nous appelons le constructeur par défaut de la classe Child2 et appelons la fonction Print() . Ici, la méthode Print() définie dans la classe Child2 sera appelée car nous avons remplacé la méthode Print() de la classe parent . Par conséquent, « Inside Child2 Class » sera imprimé sur la console.

• C’est ainsi que le remplacement de méthode est réalisé en Java.

Résultats

Dans cet article, nous avons appris ce qu'est le polymorphisme en Java. Nous avons ensuite approfondi le sujet et discuté de deux types de polymorphisme en Java : le polymorphisme au moment de la compilation et le polymorphisme au moment de l'exécution. Nous avons démontré à travers des programmes comment réaliser des liaisons statiques et dynamiques en Java.

Boucle For en Java + exemple de syntaxe de boucle forEach

Source : FreeCodeCamp Une boucle en programmation est une séquence d'instructions qui sont exécutées en continu jusqu'à ce qu'une certaine condition soit remplie. Dans cet article, nous découvrirons les boucles for et forEach en Java.

Syntaxe de la boucle For en Java

Voici la syntaxe pour créer une boucle for :

for (initialization; condition; increment/decrement) {
   // code to be executed
}

Examinons quelques-uns des mots-clés du code :

• for indique que nous allons créer une boucle. Il est suivi de parenthèses, qui contiennent tout ce dont nous avons besoin pour faire fonctionner notre boucle.

• l'initialisation définit la variable initiale comme point de départ de la boucle, généralement un entier.

• La condition spécifie combien de fois la boucle doit être exécutée.

• incrémenter / décrémenter incrémente/décrémente la valeur de la variable initiale à chaque exécution de la boucle. À mesure que la valeur de la variable augmente/diminue, elle tend vers la condition spécifiée.

• Notez que chaque mot-clé est séparé par un point-virgule ( ; ).

Voici quelques exemples:

for(int x = 1; x <=5; x++) {
  System.out.println(x);
}

/*
1
2
3
4
5
*/

Dans l'exemple ci-dessus, la variable de départ est x avec une valeur de 1. La boucle continuera à s'exécuter tant que la valeur de x est inférieure ou égale à 5 - c'est la condition. x++ incrémente la valeur de x après chaque exécution. Nous avons continué à imprimer la valeur de x qui s'arrête après 5 car la condition était remplie. Augmenter jusqu'à 6 n'est pas possible car il est supérieur et différent de 5. Dans l'exemple suivant, nous utiliserons une boucle for pour imprimer toutes les valeurs d'un tableau.

int[] randomNumbers = {2, 5, 4, 7};
for (int i = 0; i < randomNumbers.length; i++) {
  System.out.println(randomNumbers[i]);
}

// 2
// 5
// 4
// 7

C'est presque la même chose que le dernier exemple. Ici, nous avons utilisé la longueur du tableau comme condition et la valeur initiale de la variable comme zéro car le nombre ordinal du premier élément du tableau est zéro.

syntaxe de boucle forEach en Java

La boucle forEach est utilisée spécifiquement pour parcourir les éléments d’un tableau. Voici à quoi ressemble sa syntaxe :

for (dataType variableName : arrayName) {
  // code to be executed
}

Vous remarquerez que la syntaxe ici est plus courte que la boucle for . Et la boucle forEach commence également par le mot-clé for . Au lieu d'initialiser une variable avec une valeur, nous spécifions d'abord le type de données (il doit correspondre au type de données du tableau). Ceci est suivi du nom de notre variable et du nom du tableau , séparés par deux points. Voici un exemple pour vous aider à mieux comprendre la syntaxe :

int[] randomNumbers = {2, 5, 4, 7};
for (int x : randomNumbers) {
  System.out.println(x + 1);
}

/*
3
6
5
8
*/

Dans cet exemple, nous avons parcouru chaque élément et incrémenté leur valeur initiale de 1. Par défaut, la boucle s'arrête une fois qu'elle a parcouru tous les éléments du tableau. Cela signifie que nous n'avons pas besoin de transmettre de valeur à notre variable ni de spécifier de condition pour que la boucle se termine.

Conclusion

Dans cet article, nous avons appris ce que sont les boucles et la syntaxe de création de boucles for et forEach en Java. Nous avons également vu quelques exemples qui nous ont aidés à comprendre quand et comment les utiliser. Bon codage !