Überladung und Überschreibung

Einführung

In diesem Lab werden Sie die Methodenüberladung und -überschreibung lernen. Überschreibung und Überladung sind zwei Konzepte, die in der Java-Programmiersprache verwendet werden. Beide Konzepte ermöglichen es dem Programmierer, unterschiedliche Implementierungen für Methoden mit demselben Namen bereitzustellen. Die Überladung erfolgt zur Compile-Zeit, während die Überschreibung zur Laufzeit erfolgt. Statische Methoden können überladen werden, aber nicht überschrieben. Die Überladung ist eine statische Bindung, während die Überschreibung eine dynamische Bindung ist.

Skills Graph

Überladung

Im vorherigen Abschnitt haben wir bereits die Überladung in der Klasse Person verwendet, da sie drei Konstruktoren hatte. Das ist ein einfaches Beispiel. Die Überladung ist eine Eigenschaft, die es einer Klasse ermöglicht, mehrere Methoden mit demselben Namen zu haben. Dadurch können wir verschiedene Situationen behandeln und uns nicht verwirren. Typischerweise gibt es drei Möglichkeiten, die Überladung zu erreichen:

• Verschiedene Anzahl von Parametern
• Verschiedene Typen von Parametern
• Verschiedene Reihenfolge von verschiedenen Typen von Parametern

Beispiel:

Schreiben Sie folgenden Code in die Datei /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);
    }
    // diese Methode hat zwei int-Parameter und gibt einen Integer zurück
    int add(int a, int b){
        return a+b;
    }
    // diese Methode hat drei int-Parameter und gibt einen Integer zurück
    int add(int a, int b, int c){
        return a+b+c;
    }
    // diese Methode hat zwei float-Parameter und gibt eine float-Zahl zurück
    float add(float a, float b){
        return a+b;
    }
    // diese Methode hat einen String-Parameter und einen int-Parameter und gibt nichts zurück
    void printInfo(String str, int code){
        System.out.println("Code: " + code + "\nMessage: " + str);
    }
    // diese Methode hat einen int-Parameter und einen String-Parameter und gibt nichts zurück
    void printInfo(int code, String str){
        System.out.println("Code: " + code + "\nMessage: " + str);
    }
}

Ausgabe:

Führen Sie die Datei overloadingTest.java mit folgenden Befehlen aus:

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

Sehen Sie sich die Ausgabe an:

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!

Überschreibung

Wenn eine Klasse eine Methode von ihrer Superklasse erbt, besteht die Möglichkeit, die Methode zu überschreiben, sofern sie nicht als final oder private markiert ist. Durch die Überschreibung können wir ein Verhalten definieren, das für die Unterklasse spezifisch ist, was bedeutet, dass eine Unterklasse eine Methode der Superklasse gemäß ihren Anforderungen implementieren kann. Im OOP bedeutet das Überschreiben, die Funktionalität einer vorhandenen Methode zu überschreiben. Der Rückgabetyp sollte der gleiche oder ein Subtyp des im Superklasse in der ursprünglichen (überschriebenen) Methode deklarierten Rückgabetyps sein. Der Zugangsebene kann nicht restriktiver als die Zugangsebene der überschriebenen Methode sein. Beispielsweise: Wenn eine Superklassenmethode als public deklariert ist, kann die überschreibende Methode in der Unterklasse weder private noch protected sein. Wir verwenden auch den Fall von Animal (eine einfache Version).

Beispiel:

Schreiben Sie folgenden Code in die Datei /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{
    // überschreibende Methode
    public void grow(){
        System.out.println("I'm dog, I grow up.");
    }
}
class Bird extends Animal{
    // behalte die Superklasse grow(), füge eigene Anweisungen hinzu
    // überschreibende Methode
    public void grow(){
        super.grow();
        System.out.println("I'm bird, I grow up.");
    }
    // überschreibende Methode
    public void sleep(){
        System.out.println("I'm bird, I am sleeping...");
    }
    // eigene Methode von 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();
    }
}

Ausgabe:

Führen Sie die Datei overridingTest.java mit folgenden Befehlen aus:

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

Sehen Sie sich die Ausgabe an:

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

Zusammenfassung

Um ein großes Projekt zu organisieren, benötigt man eine gute Architekturdiskussion, daher sollten Sie die in diesem Lab behandelten wesentlichen Konzepte kennen. Überschreibung und Überladung bieten uns mehr Flexibilität bei der Verwendung von Methoden.