Surchargement et redéfinition de méthodes

Introduction

Dans ce laboratoire, vous allez apprendre le surchargement et la redéfinition de méthodes. Le redéfinition et le surchargement sont deux concepts utilisés dans le langage de programmation Java. Les deux concepts permettent au programmeur de fournir différentes implémentations pour des méthodes portant le même nom. Le surchargement se produit à la compilation tandis que la redéfinition se produit à l'exécution. Les méthodes statiques peuvent être surchargées mais pas redéfinies. Le surchargement est une liaison statique tandis que la redéfinition est une liaison dynamique.

Skills Graph

Surchargement

Dans la partie précédente, nous avons déjà utilisé le surchargement dans la classe Person car elle avait trois constructeurs. C'est un exemple simple. Le surchargement est une fonctionnalité qui permet à une classe d'avoir plus d'une méthode avec le même nom. Ainsi, nous pouvons gérer différentes situations et ne pas être confus. En général, il existe trois façons d'effectuer un surchargement :

• Nombre différent de paramètres
• Types différents de paramètres
• Ordre différent de types différents de paramètres

Exemple :

Écrivez le code suivant dans le fichier /home/labex/project/overloadingTest.java :

public class overloadingTest{
    public static void main(String[] args){
        overloadingTest test = new overloadingTest();
        System.out.println("add(10,20)= " + test.add(10,20));
        System.out.println("add(10,20,30)= " + test.add(10,20,30));
        System.out.println("add(5.5, 10.5)= " + test.add(5.5f, 10.5f));

        test.printInfo(1, "an error!");
        test.printInfo("another error!", 2);
    }
    // cette méthode a deux paramètres int, renvoie un entier
    int add(int a, int b){
        return a+b;
    }
    // cette méthode a trois paramètres int, renvoie un entier
    int add(int a, int b, int c){
        return a+b+c;
    }
    // cette méthode a deux paramètres float, renvoie un nombre float
    float add(float a, float b){
        return a+b;
    }
    // cette méthode a un paramètre string et un paramètre int, ne renvoie rien
    void printInfo(String str, int code){
        System.out.println("Code: " + code + "\nMessage: " + str);
    }
    // cette méthode a un paramètre int et un paramètre string, ne renvoie rien
    void printInfo(int code, String str){
        System.out.println("Code: " + code + "\nMessage: " + str);
    }
}

Sortie :

Exécutez le fichier overloadingTest.java en utilisant les commandes suivantes :

javac /home/labex/project/overloadingTest.java
java overloadingTest

Voyez la sortie :

add(10,20)= 30
add(10,20,30)= 60
add(5.5, 10.5)= 16.0
Code: 1
Message: an error!
Code: 2
Message: another error!

Redéfinition

Si une classe hérite d'une méthode de sa superclasse, alors il y a une chance de redéfinir la méthode à condition qu'elle ne soit pas marquée final ou private. En redéfinissant, nous pouvons définir un comportement spécifique à la sous-classe, ce qui signifie qu'une sous-classe peut implémenter une méthode de la classe parente selon ses besoins. En POO, la redéfinition signifie redéfinir la fonctionnalité d'une méthode existante. Le type de retour devrait être le même ou un sous-type du type de retour déclaré dans la méthode d'origine (redéfinie) dans la superclasse. Le niveau d'accès ne peut pas être plus restrictif que le niveau d'accès de la méthode redéfinie. Par exemple : Si une méthode de superclasse est déclarée public, alors la méthode de redéfinition dans la sous-classe ne peut pas être private ou protected. Nous utilisons également l'exemple de Animal (une version simple).

Exemple :

Écrivez le code suivant dans le fichier /home/labex/project/overridingTest.java :

class Animal{
    public void grow(){
        System.out.println("I'm animal, I grow up.");
    }
    public void sleep(){
        System.out.println("I'm animal, I am sleeping.");
    }
}
class Dog extends Animal{
    // méthode de redéfinition
    public void grow(){
        System.out.println("I'm dog, I grow up.");
    }
}
class Bird extends Animal{
    // conserver grow() de la superclasse, ajouter ses propres instructions
    // méthode de redéfinition
    public void grow(){
        super.grow();
        System.out.println("I'm bird, I grow up.");
    }
    // méthode de redéfinition
    public void sleep(){
        System.out.println("I'm bird, I am sleeping...");
    }
    // méthode propre à Bird
    public void sing(){
        System.out.println("I'm bird, I am singing a song...");
    }
}
public class overridingTest{
    public static void main(String[] args){
        Dog dog = new Dog();
        dog.grow();
        Bird bird = new Bird();
        bird.grow();
    }
}

Sortie :

Exécutez le fichier overridingTest.java en utilisant les commandes suivantes :

javac /home/labex/project/overridingTest.java
java overridingTest

Voyez la sortie :

I'm dog, I grow up.
I'm animal, I grow up.
I'm bird, I grow up.

Récapitulatif

Pour organiser un grand projet, il est nécessaire d'avoir une bonne idée d'architecture, donc vous devriez connaître les concepts essentiels abordés dans ce laboratoire. La redéfinition et le surchargement nous donnent plus de flexibilité pour utiliser les méthodes.