In diesem Artikel erfahren Sie mehr über das Überladen von Funktionen, wann wir das Überladen von Funktionen benötigen und wie Sie mit Beispielen überladen.
Zwei oder mehr Funktionen mit demselben Namen, aber unterschiedlichen Argumenten werden als überladene Funktionen bezeichnet.
Warum brauchen wir Funktionsüberladung?
Stellen Sie sich vor, Sie entwickeln ein Shooter-Spiel, in dem der Spieler seine Feinde mit einem Messer, einer Klinge und einer Waffe angreifen kann. Ihre Lösung für die Angriffsfunktion könnte darin bestehen, die Aktionen in folgende Funktionen zu definieren:
func attack() ( //… print("Attacking with Knife") ) func attack() ( //… print("Attacking with Blade") ) func attack() ( //… print("Attacking with Gun") )
Wenn Sie jedoch versuchen, das oben genannte Programm auszuführen, wird in Swift ein Fehler bei der Kompilierung als 'attack ()' angezeigt, der zuvor hier deklariert wurde . Eine andere Lösung könnte jedoch darin bestehen, unterschiedliche Funktionsnamen für die jeweilige Funktionalität zu definieren als:
struct Knife ( ) struct Gun ( ) struct Blade ( ) func attackUsingKnife(weapon:Knife) ( //… print("Attacking with Knife") ) func attackUsingBlade(weapon:Blade) ( //… print("Attacking with Blade") ) func attackUsingGun(weapon:Gun) ( //… print("Attacking with Gun") )
Mach dir keine Sorgen, wenn du nicht weißt, was Struktur ist. Stellen Sie sich das vorerst als etwas vor, das beim Programmieren ein physisches Objekt erzeugt, also erstellen Sie ein Messer, eine Waffe und eine Klinge. Wenn Sie mehr wissen möchten, lesen Sie Swift Struct. Wenn nicht, werden wir in den späteren Kapiteln darauf zurückkommen.
Das einzige Problem bei dieser Lösung besteht darin, dass Sie sich die Funktionsnamen merken müssen, um diese bestimmte Angriffsaktion aufzurufen. Wenn der Level steigt, kann der Spieler zusätzliche Funktionen für Angriffe mit Bomben, Granaten, Schrotflinten usw. haben.
Das Erstellen von Funktionen mit unterschiedlichen Namen ist zeitaufwändig und erhöht den Aufwand für das Speichern des Funktionsnamens, um ihn aufzurufen. Alles in allem ist es nicht intuitiv.
Es wäre viel besser, wenn Sie verschiedene Funktionen mit demselben Namen, aber unterschiedlicher Implementierung für jede Waffe erstellen könnten. Auf diese Weise reicht es aus, sich einen Funktionsnamen zu merken, und Sie müssen sich keine Gedanken über die Funktionsnamen anderer Waffen machen.
Was ist Funktionsüberladung?
Der soeben beschriebene Prozess wird als Funktionsüberladung bezeichnet. Per Definition wird der Vorgang des Erstellens von zwei oder mehr als zwei Funktionen mit demselben Namen, aber unterschiedlicher Anzahl oder Art von übergebenen Parametern als Funktionsüberladung bezeichnet.
Sehen wir uns das folgende Beispiel an:
Beispiel 1: Funktionsüberladung
struct Knife ( ) struct Gun ( ) struct Blade ( ) func attack(with weapon:Knife) ( print("Attacking with Knife") ) func attack(with weapon:Gun) ( print("Attacking with Gun") ) func attack(with weapon:Blade) ( print("Attacking with Blade") ) attack(with: Gun()) attack(with: Blade()) attack(with: Knife())
Wenn Sie das obige Programm ausführen, lautet die Ausgabe wie folgt:
Mit der Waffe angreifen Mit der Klinge angreifen Mit dem Messer angreifen
Im obigen Programm haben wir drei verschiedene Funktionen mit demselben Namen erstellt attack. Es werden jedoch unterschiedliche Parametertypen akzeptiert. Auf diese Weise reicht es aus, sich den attackNamen zu merken , um die Funktion aufzurufen.
- Der Aufruf
attack(with: Gun())löst die Anweisung innerhalb der Funktion ausfunc attack(with weapon:Gun). - Der Aufruf
attack(with: Blade())löst die Anweisung innerhalb der Funktion ausfunc attack(with weapon:Blade). - Die call-
attack(with: Knife())Anweisung innerhalb der Funktionfunc attack(with weapon:Knife).
Beispiel 2: Funktionsüberladung basierend auf verschiedenen Parametertypen
func output(x:Int) ( print("The int value is (x)") ) func output(x:String) ( print("The string value is (x)") ) output(x: 2) output(x: "Swift")
Wenn Sie das obige Programm ausführen, lautet die Ausgabe wie folgt:
Der int-Wert ist 2 Der String-Wert ist Swift
Im obigen Programm haben wir zwei Funktionen mit demselben Namen output()und derselben Anzahl von Parametern. Die erste output()Funktion verwendet jedoch eine Ganzzahl als Parameter und die zweite output()Funktion Stringals Parameter.
Ähnlich wie in Beispiel 1,
- Der Aufruf von
output(x: 2)löst die Anweisung innerhalb der Funktionfunc output(x:Int)und aus - Der Aufruf von
output(x: "Swift")löst die Anweisung innerhalb der Funktion ausfunc output(x:String).
Beispiel 3: Funktionsüberladung basierend auf unterschiedlicher Anzahl von Parametern
func output() ( print("Good Morning!") ) func output(text:String) ( print(text) ) func output(text:String, num:Int) ( print("(text)(num)!") ) output() output(text: "Good Evening!") output(text1: "Good N", num: 8)
Wenn Sie das obige Programm ausführen, lautet die Ausgabe wie folgt:
Guten Morgen! Guten Abend! Gute Nacht!
Im obigen Programm wurde die Funktion output()basierend auf der Anzahl der Argumente überladen.
Der erste output()nimmt keine Parameter an, der zweite output()nimmt einen einzelnen Parameter an: Stringund der dritte output()nimmt zwei Parameter an: Stringund Int.
Versuchen wir zu überladen, indem wir den Parameternamen ändern, aber die Argumentbezeichnung wie folgt beibehalten:
Beispiel 4: Funktionsüberladung mit derselben Argumentbezeichnung
func output(value text:String) ( print(text) ) func output(value num:Int) ( print(num) ) output(value: 2) output(value: "Hello")
Wenn Sie das obige Programm ausführen, lautet die Ausgabe wie folgt:
2 Hallo
Wie Sie sehen können, können Sie im obigen Programm dieselbe Argumentbezeichnung für die überladenen Funktionen verwenden. Je nach Überladung müssen Sie jedoch entweder eine unterschiedliche Anzahl von Parametern oder unterschiedliche Arten von Parametern haben.
