În acest articol, veți afla despre supraîncărcarea funcției, când trebuie să supraîncărcați funcția și cum să supraîncărcați cu exemple.
Două sau mai multe funcții cu același nume, dar diferite argumente sunt cunoscute sub numele de funcții supraîncărcate.
De ce avem nevoie de supraîncărcare a funcției?
Imaginați-vă că dezvoltați un joc shooter în care jucătorul își poate ataca dușmanii folosind un cuțit, o lamă și o armă. Soluția dvs. pentru funcționalitatea atacului ar putea fi definirea acțiunilor în funcții ca:
func attack() ( //… print("Attacking with Knife") ) func attack() ( //… print("Attacking with Blade") ) func attack() ( //… print("Attacking with Gun") )
Dar când încercați să rulați programul de mai sus, veți primi o eroare de timp de compilare în Swift ca „atac ()” declarat anterior aici . Cu toate acestea, o altă soluție ar putea fi definirea diferitelor nume de funcții pentru funcționalitatea specială ca:
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") )
Nu vă faceți griji dacă nu știți ce este structura. Deocamdată gândiți-vă la el ca la ceva care creează un obiect fizic în programare, astfel încât să creați un cuțit, pistol și lamă. Dacă doriți să aflați mai multe, consultați Swift Struct. Dacă nu, vom reveni la aceasta în capitolele ulterioare.
Singura problemă cu această soluție este că trebuie să vă amintiți numele funcțiilor pentru a apela acea acțiune specială de atac. De asemenea, pe măsură ce nivelul crește, jucătorul poate avea caracteristici suplimentare pentru atac folosind bombă, grenadă, pușcă etc.
Crearea funcției cu nume diferite necesită mult timp și crește cheltuielile generale pentru amintirea numelui funcției pentru a o apela. Una peste alta, nu este intuitiv.
Ar fi mult mai bine dacă ați putea crea funcții diferite cu același nume, dar implementare diferită pentru fiecare armă. În acest fel, reținerea unui nume de funcție este suficientă și nu ar trebui să vă faceți griji cu privire la numele funcțiilor pentru alte arme.
Ce este supraîncărcarea funcției?
Procesul pe care tocmai l-am descris este cunoscut sub numele de supraîncărcare a funcțiilor. Prin definiție, procesul de creare a două sau mai mult de două funcții cu același nume, dar care au un număr sau tipuri diferite de parametri trecuți, este cunoscut sub numele de supraîncărcare a funcțiilor.
Să vedem acest lucru în exemplul de mai jos:
Exemplul 1: supraîncărcarea funcției
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())
Când rulați programul de mai sus, ieșirea va fi:
Atac cu arma Atac cu lama Atac cu cuțitul
În programul de mai sus, am creat trei funcții diferite cu același nume attack. Cu toate acestea, acceptă diferite tipuri de parametri. În acest fel, attackeste suficient să ne amintim numele pentru a apela funcția.
- Apelul
attack(with: Gun())declanșează declarația din interiorul funcțieifunc attack(with weapon:Gun). - Apelul
attack(with: Blade())declanșează declarația din interiorul funcțieifunc attack(with weapon:Blade). - Declarația de apel din
attack(with: Knife())interiorul funcțieifunc attack(with weapon:Knife).
Exemplul 2: Supraîncărcarea funcției pe baza diferitelor tipuri de parametri
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")
Când rulați programul de mai sus, ieșirea va fi:
Valoarea int este 2 Valoarea șirului este Swift
În programul de mai sus, avem două funcții cu același nume output()și același număr de parametri. Cu toate acestea, prima output()funcție ia un număr întreg ca parametru, iar a doua output()funcție ia Stringca parametru.
Similar cu exemplul 1,
- apelul către
output(x: 2)declanșează declarația din interiorul funcțieifunc output(x:Int)și - apelul către
output(x: "Swift")declanșează declarația din interiorul funcțieifunc output(x:String).
Exemplul 3: supraîncărcarea funcției pe baza unui număr diferit de parametri
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)
Când rulați programul de mai sus, ieșirea va fi:
Buna dimineata! Bună seara! Noapte bună!
În programul de mai sus, funcția output()a fost supraîncărcată pe baza numărului de argumente.
Primul output()nu ia parametri, al doilea output()ia un singur parametru:, Stringiar al treilea output()ia doi parametri: Stringși Int.
Să încercăm să suprasolicităm schimbând numele parametrului, dar păstrând eticheta argumentului la fel ca:
Exemplul 4: supraîncărcarea funcției cu aceeași etichetă de argument
func output(value text:String) ( print(text) ) func output(value num:Int) ( print(num) ) output(value: 2) output(value: "Hello")
Când rulați programul de mai sus, ieșirea va fi:
2 Bună ziua
După cum puteți vedea, în programul de mai sus, puteți utiliza aceeași etichetă de argument pentru funcțiile supraîncărcate. Cu toate acestea, așa cum necesită supraîncărcarea, trebuie să aveți fie un număr diferit de parametri, fie diferite tipuri de parametri.
