Sobrecarga de Funções Swift

Neste artigo, você aprenderá sobre função sobreescrita, quando precisamos de função sobreescrita e como sobreescrita de exemplo.

com o mesmo nome mas com diferentes parâmetrosFunçãoChamada de função sobreescrita.

Por que precisamos de função sobreescrita?

Imaginando que você está desenvolvendo um jogo de tiro, onde o jogador pode atacar com espadas, espadas e pistolas. Sua solução para a função de ataque pode ser definir a operação como função:

func attack() {
　　　　//..
　　　　print("ataque com espada")
}
func attack() {
　　　　//..
　　　　print("用剑攻击")
}
func attack() {
　　　　//..
　　　　print("ataque com pistola")
}

Mas, ao tentar executar o programa acima, você receberá erros de compilação no Swift, como 'attack()' previamente declarado aqui。Mas, outra solução pode ser definir nomes de funções diferentes para funções específicas, conforme mostrado a seguir:

struct Knife {
}
struct Gun {
}
struct Blade {
}
func attackUsingKnife(weapon: Knife) {
　　　　//..
　　　　print("ataque com espada")
}
func attackUsingBlade(weapon: Blade) {
　　　　//..
　　　　print("用剑攻击")
}
func attackUsingGun(weapon: Gun) {
　　　　//..
　　　　print("ataque com pistola")
}

Se você não sabe o que é struct, não se preocupe. Agora, considere-o como algo que cria objetos físicos em programação, então você está criando uma espada, pistola e espada.

O único problema com essa solução é que você precisa lembrar-se do nome da função para chamar a operação de ataque específica. Da mesma forma, conforme o aumento do nível, o jogador pode ter outras funções de ataque, como bombas, granadas, rifles e outros.

Criar funções com nomes diferentes é demorado e aumenta o custo de memorização dos nomes das funções para chamá-las. Em resumo, isso não é muito intuitivo.

Se pudermos criar funções diferentes com o mesmo nome para cada tipo de arma, isso seria melhor. Dessa forma, lembrar-se de um único nome de função seria suficiente, e você não precisaria se preocupar com os nomes das funções de outras armas.

O que é função sobreescrita?

O processo que acabamos de descrever é chamado de função sobreescrita. De acordo com a definição, o processo de criar duas ou mais funções com o mesmo nome mas com diferentes números ou tipos de parâmetros passados é chamado de função sobreescrita.

Vamos ver isso em um exemplo a seguir:

Exemplo1：função sobreescrita

struct Knife {
}
struct Gun {
}
struct Blade {
}
func attack(with weapon: Knife) {
　　　　print("ataque com espada")
}
func attack(with weapon: Gun) {
　　　　print("ataque com pistola")
}
func attack(with weapon: Blade) {
　　　　print("用剑攻击")
}
attack(with: Gun())
attack(with: Blade())
attack(with: Knife())

Quando você executar o programa acima, a saída será:

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

在以上程序中，我们创建了三个具有相同名称的不同函数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) 语句。

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

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

Quando você executar o programa acima, a saída será:

int值是　2
字符串值是 Swift

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

与示例1类似，

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

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

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

func output() {
　　　　print("Bom Dia!")
}
func output(text: String) {
　　　　print(text)
}
func output(text: String, num: Int) {
　　　　print("(text)(num)!")
}
output()
output(text: "Boa Noite!")
output(text1: "Bom N", num:　8)

Quando você executar o programa acima, a saída será:

Bom Dia!
Boa Noite!
Boa Noite!

No programa acima, a função output() foi sobrecarregada com base no número de parâmetros.

O primeiro output() sem parâmetros, o segundo output() com um parâmetro: String, o terceiro output() com dois parâmetros: String e Int.

Vamos tentar sobrecarregar através de alteração do nome do parâmetro, mas mantendo as etiquetas de parâmetro inalteradas, conforme mostrado a seguir:

Exemplo4：Sobrecarga de funções com etiquetas de parâmetros idênticas

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

Quando você executar o programa acima, a saída será:

2
Olá

Como você vê, no programa acima, é possível usar a mesma etiqueta de parâmetro para funções sobrecarregadas. No entanto, de acordo com os requisitos de sobrecarga, você deve ter um número diferente de parâmetros ou parâmetros de tipos diferentes.