Wie gehe ich mit doppelten Methodennamen in Java um?

Als objektorientierte Programmiersprache sind Javas Kernideen Kapselung, Vererbung und Polymorphismus. Die Duplizierung von Methodennamen ist ein häufiges Problem in Java, das normalerweise bei der Vererbung und Schnittstellenimplementierung auftritt. In diesem Artikel erfahren Sie, wie Sie mit doppelten Methodennamen in Java umgehen.

1. Überladung von Methodennamen

In derselben Klasse können die Methodennamen gleich sein, was als Methodenüberladung (Überladung) bezeichnet wird. Methodenüberladung bedeutet, dass mehrere Versionen desselben Methodennamens in derselben Klasse vorhanden sein dürfen. Ihre Parameterlisten sind unterschiedlich (unterschiedliche Anzahl von Parametern oder unterschiedliche Parametertypen), der Methodenrückgabetyp kann jedoch gleich oder unterschiedlich sein. Beim Aufruf einer Methode bestimmt der Compiler anhand des Typs und der Anzahl der übergebenen Parameter, welche Methode aufgerufen werden soll.

Der folgende Code definiert beispielsweise zwei Methoden namens „add“ mit unterschiedlicher Anzahl und Art von Parametern:

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;
    }
}

Auf diese Weise wählt der Compiler beim Aufruf der Add-Methode automatisch Typ und Menge aus und wählt die entsprechende Methode aus Aufruf:

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

2. Überschreiben des Methodennamens

Wenn die Unterklasse im Vererbungsprozess von Java eine Methode mit demselben Namen wie die übergeordnete Klasse definiert, überschreibt die Unterklasse die Methode der übergeordneten Klasse mit demselben Namen. Diese Situation wird als Methodenüberschreibung bezeichnet.

Das Prinzip des Überschreibens lautet: Die Methode in der Unterklasse muss denselben Rückgabetyp, denselben Methodennamen und dieselbe Parameterliste wie die Methode in der übergeordneten Klasse haben (Anzahl und Typ der Parameter sind gleich). Wenn eine Unterklasse außerdem eine Methode einer übergeordneten Klasse überschreibt, dürfen die Zugriffsrechte nicht geringer sein als die Zugriffsrechte der Methode in der übergeordneten Klasse.

Zum Beispiel definiert der folgende Code eine Methode namens „print“, die sowohl in der übergeordneten Klasse als auch in der untergeordneten Klasse vorhanden ist:

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.");
    }
}

Wenn wir die print-Methode der Cat-Instanz aufrufen, lautet „This is a cat“. Ausgabe .“ weil die Cat-Klasse die print-Methode in der Animal-Klasse überschreibt.

3. Wiederholte Methodennamen in Schnittstellen

In Java-Schnittstellen können Sie mehrere Methoden mit demselben Methodennamen definieren, aber der Parametertyp und die Anzahl müssen unterschiedlich sein. Dies wird als Methodenwiederholung (Repeating) bezeichnet.

Der folgende Code definiert beispielsweise eine Schnittstelle mit dem Namen „f“, die drei Methoden mit demselben Methodennamen, aber unterschiedlichen Parametern definiert:

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

Die Klasse, die diese Schnittstelle implementiert, muss diese drei Methoden implementieren. Der folgende Code implementiert beispielsweise die Beispielschnittstelle:

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);
    }
}

Auf diese Weise wählt der Compiler beim Aufrufen der f-Methode der MyExample-Instanz automatisch die entsprechende aufzurufende Methode basierend auf dem Typ und der Anzahl der übergebenen Parameter aus. Zum Beispiel:

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

4. Zusammenfassung

Das Duplizieren von Methodennamen ist ein häufiges Problem in Java. Es gibt drei Lösungen: Methodenüberladung, Methodenüberschreibung und Methodenduplizierung. Beim Schreiben von Code müssen wir je nach tatsächlicher Situation unterschiedliche Methoden zur Lösung auswählen. Gleichzeitig müssen wir auch darauf achten, die Namenskonvention von Java einzuhalten. Die Namenskonvention ist klar und prägnant, was zur Verbesserung der Lesbarkeit und Wartbarkeit des Codes beiträgt.

Das obige ist der detaillierte Inhalt vonWie gehe ich mit doppelten Methodennamen in Java um?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!