Swift Funktionsüberladung

In diesem Artikel werden Sie Funktionsoverladung, wann Funktionsoverladung erforderlich ist und wie Beispiele für die Überladung kennenlernen.

mit demselben Namen, aber unterschiedlichen ParameternFunktionenbenannt als überladene Funktion.

Warum benötigen wir Funktionsoverladung?

Stellen Sie sich vor, Sie entwickeln ein Schießspiel, bei dem der Spieler mit einem Schwert, einer Axt und einem Gewehr auf Feinde angreifen kann. Ihre Lösung für die Angriffsfunction könnte darin bestehen, die Operation als Funktion zu definieren:

func attack() {
　　　　//..
　　　　print("mit Schwert angreifen")
}
func attack() {
　　　　//..
　　　　print("用剑攻击")
}
func attack() {
　　　　//..
　　　　print("mit Gewehr angreifen")
}

Wenn Sie jedoch versuchen, das obige Programm auszuführen, erhalten Sie in Swift kompilationszeitliche Fehler wie 'attack()' wurde hier bereits deklariert。但是，另一种解决方案 könnte darin bestehen， für spezifische Funktionen unterschiedliche Funktionsnamen zu definieren, wie folgt:

struct Knife {
}
struct Gun {
}
struct Blade {
}
func attackUsingKnife(weapon: Knife) {
　　　　//..
　　　　print("mit Schwert angreifen")
}
func attackUsingBlade(weapon: Blade) {
　　　　//..
　　　　print("用剑攻击")
}
func attackUsingGun(weapon: Gun) {
　　　　//..
　　　　print("mit Gewehr angreifen")
}

Wenn Sie nicht wissen, was struct ist, machen Sie sich keine Sorgen. Jetzt können Sie es einfach als etwas betrachten, das im Programmieren zur Erstellung von physischen Objekten dient, dann erstellen Sie ein Schwert, ein Gewehr und ein Schwert.

Das einzige Problem mit dieser Lösung ist, dass Sie sich die Funktionsnamen merken müssen, um den spezifischen Angriffsvorgang aufzurufen. Ebenso haben Spieler mit höherem Level möglicherweise andere Funktionen, um mit Bomben, Handgranaten, Jagdgewehren usw. zu angreifen.

Die Erstellung von Funktionen mit unterschiedlichen Namen ist zeitaufwendig und erhöht den Aufwand, die Namen der Funktionen zu merken, um sie aufzurufen. Kürzer gesagt, das ist nicht sehr intuitiv.

Wenn es besser wäre, für jedes Waffe eine unterschiedliche Funktion mit demselben Namen zu erstellen, dann wäre das besser. Auf diese Weise reicht es aus, eine Funktion zu merken, und Sie müssen sich keine Sorgen um die Namen der Funktionen anderer Waffen machen.

Was ist Funktionsoverladung?

Der beschriebene Prozess wird als Funktionsoverladung bezeichnet. Laut Definition ist der Prozess der Erstellung von zwei oder mehr Funktionen mit demselben Namen, die unterschiedliche Parameterzahlen oder -typen haben, als Funktionsoverladung bekannt.

Wir sehen das in den folgenden Beispielen:

Beispiel1：Funktionsoverladung

struct Knife {
}
struct Gun {
}
struct Blade {
}
func attack(with weapon: Knife) {
　　　　print("mit Schwert angreifen")
}
func attack(with weapon: Gun) {
　　　　print("mit Gewehr angreifen")
}
func attack(with weapon: Blade) {
　　　　print("用剑攻击")
}
attack(with: Gun())
attack(with: Blade())
attack(with: Knife())

Wenn Sie das obige Programm ausführen, wird die Ausgabe sein:

用枪攻击
用剑攻击
用刀攻击

在以上程序中，我们创建了三个具有相同名称的不同函数attack。但是，它接受不同的参数类型。这样，记住 attack 名称即可调用函数。

• 调用 attack(with: Gun()) 将触发函数内部的 func attack(with weapon:Gun) 语句。

• 调用 attack(with: Blade()) 将触发函数内部的 func attack(with weapon:Blade) 语句。

• 调用 attack(with: Knife()) 将触发函数内部的 func attack(with weapon:Knife) 语句。

Beispiel2：基于不同参数类型的函数重载

func output(x: Int) {
　　　　print("int值是 (x)")
}
func output(x: String) {
　　　　print("字符串值是 (x)")
}
output(x:　2)
output(x: "Swift")

Wenn Sie das obige Programm ausführen, wird die Ausgabe sein:

int值是　2
字符串值是 Swift

在上面的程序中，我们有两个具有相同名称和相同数量参数的函数output()。但是，第一个output()函数将整数作为参数，第二个output()函数将String参数作为参数。

与示例1类似，

• 调用 output(x: 2) 会触发函数内部的 func output(x:Int) 语句

• 调用 output(x: "Swift") 会触发函数内部的 func output(x:String) 语句。

Beispiel3：基于不同数量参数的函数重载

func output() {
　　　　print("Guten Morgen!")
}
func output(text: String) {
　　　　print(text)
}
func output(text: String, num: Int) {
　　　　print("(text)(num)!")
}
output()
output(text: "Guten Abend!")
output(text1: "Guten N", num:　8)

Wenn Sie das obige Programm ausführen, wird die Ausgabe sein:

Guten Morgen!
Guten Abend!
Gute Nacht!

In dem obigen Programm wurde die Funktion output() gemäß der Anzahl der Parameter überladen.

Der erste output() ohne Parameter, der zweite output() mit einem Parameter: String, der dritte output() mit zwei Parametern: String und Int.

Lassen Sie uns versuchen, durch Ändern der Parametername zu überladen, aber die Parameteretiketten bleiben unverändert, wie folgt:

Beispiel4：Funktionen mit gleichen Parameteretiketten überladen

func output(value text:String) {
　　　　print(text)
}
func output(value num:Int) {
　　　　print(num)
}
output(value:　2)
output(value: "Hallo")

Wenn Sie das obige Programm ausführen, wird die Ausgabe sein:

2
Hallo

Wie Sie sehen können, können Sie in dem obigen Programm aufgeladene Funktionen mit denselben Parameteretiketten verwenden. Aber gemäß den Anforderungen der Überladung müssen Sie unterschiedliche Anzahl an Parametern oder unterschiedliche Parameterarten haben.