Comment gérer les noms de méthodes en double en Java ?

En tant que langage de programmation orienté objet, les idées fondamentales de Java sont l'encapsulation, l'héritage et le polymorphisme. En Java, les noms de méthodes en double constituent un problème courant, qui se produit généralement lors de l'héritage et de l'implémentation de l'interface. Cet article explique comment gérer les noms de méthodes en double en Java.

1. Surcharge de noms de méthodes

Dans la même classe, les noms de méthodes peuvent être les mêmes, ce qui est appelé surcharge de méthode (Surcharge). La surcharge de méthode signifie que plusieurs versions du même nom de méthode peuvent exister dans la même classe. Leurs listes de paramètres sont différentes (nombre de paramètres différent ou types de paramètres différents), mais le type de retour de la méthode peut être identique ou différent. Lors de l’appel d’une méthode, le compilateur déterminera quelle méthode doit être appelée en fonction du type et du nombre de paramètres transmis.

Par exemple, le code suivant définit deux méthodes nommées "add" avec un nombre et des types de paramètres différents :

public class MathUtil {
    public static int add(int x, int y) {
        return x + y;
    }
    
    public static double add(double x, double y) {
        return x + y;
    }
}

De cette façon, lorsque la méthode add est appelée, le compilateur va automatiquement saisir le type et la quantité, sélectionner la méthode correspondante pour appelez :

int result1 = MathUtil.add(1, 2); // 调用第一个add方法
double result2 = MathUtil.add(1.0, 2.0); // 调用第二个add方法

2. Remplacement du nom de la méthode

Dans le processus d'héritage de Java, si la sous-classe définit une méthode avec le même nom que la classe parent, alors la sous-classe écrasera la méthode de la classe parent avec le même nom. Cette situation est appelée remplacement de méthode.

Le principe de l'écrasement est le suivant : la méthode de la sous-classe doit avoir le même type de retour, le même nom de méthode et la même liste de paramètres que la méthode de la classe parent (le nombre et le type de paramètres sont les mêmes). De plus, lorsqu'une sous-classe substitue une méthode d'une classe parent, les droits d'accès ne peuvent pas être inférieurs aux droits d'accès de la méthode dans la classe parent.

Par exemple, le code suivant définit une méthode nommée "print", qui existe à la fois dans la classe parent et dans la classe enfant :

public class Animal {
    public void print() {
        System.out.println("This is an animal.");
    }
}

public class Cat extends Animal {
    @Override
    public void print() {
        System.out.println("This is a cat.");
    }
}

Lorsque nous appelons la méthode print de l'instance Cat, "This is a cat" sera output . " car la classe Cat remplace la méthode d'impression dans la classe Animal.

3. Noms de méthodes répétés dans les interfaces

Dans les interfaces Java, vous pouvez définir plusieurs méthodes avec le même nom de méthode, mais le type et le numéro du paramètre doivent être différents. C'est ce qu'on appelle la répétition de méthode (Répétition).

Par exemple, le code suivant définit une interface nommée "f", qui définit trois méthodes avec le même nom de méthode, mais des paramètres différents :

public interface Example {
    void f(int x);
    void f(double x);
    void f(String s);
}

La classe qui implémente cette interface doit implémenter ces trois méthodes. Par exemple, le code suivant implémente l'interface Exemple :

public class MyExample implements Example {
    @Override
    public void f(int x) {
        System.out.println("f(int): " + x);
    }

    @Override
    public void f(double x) {
        System.out.println("f(double): " + x);
    }

    @Override
    public void f(String s) {
        System.out.println("f(String): " + s);
    }
}

De cette façon, lors de l'appel de la méthode f de l'instance MyExample, le compilateur sélectionnera automatiquement la méthode correspondante à appeler en fonction du type et du nombre de paramètres transmis. Par exemple :

Example example = new MyExample();
example.f(123); // 调用MyExample中的f(int)方法
example.f(456.0); // 调用MyExample中的f(double)方法
example.f("Hello"); // 调用MyExample中的f(String)方法

4. Résumé

La duplication des noms de méthodes est un problème courant en Java. Il existe trois solutions : la surcharge de méthode, l'écrasement de méthode et la duplication de méthode. Lors de l'écriture du code, nous devons choisir différentes méthodes pour le résoudre en fonction de la situation réelle. Dans le même temps, nous devons également faire attention au respect de la convention de dénomination des méthodes Java. La convention de dénomination est claire et concise, ce qui contribue à améliorer la lisibilité et la maintenabilité du code.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!