În primul rând, trebuie să decideți ce metode sunt supraîncărcate și cum să lucrați cu ele.
Metodele suprasolicitate urmează calea polimorfismului și, ca și metodele virtuale, vă permit să înlocuiți aceeași metodă, cu același nume.
Pentru a fi mai precis, metodele supraîncărcate nu suprascrie o anumită metodă, ci doar o completează cu o altă copie modificată.
O dată vom da un exemplu în cod, că pentru voi ar fi mai clar.
utilizând Sistemul;
folosind System.Collections.Generic;
folosind System.Linq;
folosind System.Text;
namespace ConsoleApplication5
<
clasă
<
static void Principal (șir [] args)
//
some_func ();
some_func ("Bună ziua poate");
static public void some_func ()
Console.WriteLine ("Nu am primit niciun text");
static public void some_func (string some_text)
Console.WriteLine ("Ați primit text" + Some_text);
Exemplul de mai sus va afișa următoarele rânduri:
Am primit text. Gayul ar putea
Ie Am creat două metode identice după nume, dar cu parametri de intrare diferit.
Aceasta se numește supraîncărcarea metodei, atunci când o metodă are reprezentări diferite.
Dar, cum ar trebui să se facă distincția între ei?
Destul de simplu, ele diferă în parametrii de intrare.
Și pentru a fi exact, de tipurile de parametri de intrare sau de numărul lor.
Adică, puteți declara cel puțin 100500 de metode identice, dar ele trebuie să difere în numărul de parametri de intrare sau în funcție de tipul acestora.
Următorul exemplu demonstrează clar acest lucru.
utilizând Sistemul;
folosind System.Collections.Generic;
folosind System.Linq;
folosind System.Text;
namespace ConsoleApplication5
<
clasă
<
static void Principal (șir [] args)
//
some_func ();
some_func ("Bună ziua poate");
some_func ("Bună ziua", "Cum te simți?");
some_func (100, 500);
static public void some_func ()
Console.WriteLine ("Nu am primit niciun text");
static public void some_func (string some_text)
Console.WriteLine ("Ați primit text" + Some_text);
static public void some_func (șir some_text, string some_text2)
Console.WriteLine ("Are două linii" + Some_text + "-and-" + some_text2);
statică publică void some_func (int some_text, int some_text2)
Console.WriteLine ("Aveți două numere" + Some_text + "-and-" + some_text2);
După pornirea codului, pe ecran va apărea următorul text:
Am primit text. Gayul ar putea
Am două rânduri. Bună ziua - și cum ești?
Am două numere. 100 și 500
După cum puteți vedea, am declarat 4 metode identice, dar cu parametri diferiți.
C # însuși află ce parametri sunt trecuți și câte și apoi îi sună pe cea care se potrivește tipului de parametri specificați și / sau numărului acestora.
De ce este necesar?
În primul rând, este foarte convenabil.
În al doilea rând, îmbunătățește codul.
În al treilea rând, puteți supraîncărca nu numai metodele simple, ci și constructorii de clasă, dar mai multe despre acest lucru mai târziu în articol.
Și pentru un exemplu mai ilustrativ, vom da limba C.
În C, există metoda ABS (), care returnează valoarea absolută a unui întreg.
De asemenea, în C, există metoda LABS (), care returnează valoarea absolută a unui întreg lung.
Și în C, există metoda FABS (), care returnează valoarea absolută a unui număr de punct variabil de precizie obișnuită (unică).
Dar, de fapt, toate aceste trei funcții îndeplinesc aceeași sarcină, diferențiind doar parametrii de intrare.
Acest lucru se datorează faptului că C nu suportă metode supraîncărcate și este necesar să se apeleze la fiecare funcție și / sau copia sa un nume unic.
Și în C #, există o singură funcție ABS () în spațiul de nume Sistem, din clasa Math, iar această singură funcție îndeplinește funcția celor trei enumerate în C, motiv pentru care capacitatea de a suprasolicita metodele este atât de convenabilă.
Ce se ascunde sub capota?
C # poate face distincția între funcțiile supraîncărcate și, în general, le permite să lucreze cu semnături.
Semnăturile indică numele metodei, precum și parametrii, numărul și tipurile acestora.
Astfel, în C #, o clasă nu poate avea aceeași metodă cu același număr de parametri și / sau tipuri de parametri.
Tipul returnat de metodă nu este luat în considerare în semnături, motiv pentru care nu afectează decizia C #.
De asemenea, parametrii modificatori nu afectează soluția C #.
Supraîncărcarea constructorului de clasă.
Constructorul din această clasă poate fi supraîncărcat.
șir protejat animal_name;
public Animale ()
<
animal_name = "undefined";
Console.WriteLine ("Nu există niciun nume de animal");
>
public Animale (numele șirului)
<
animal_name = nume;
Console.WriteLine ("Numele animalului este" + nume);
>
public virtual void Print_Name ()
<
//
Console.WriteLine ("Numele animalului este." + Animal_name);
>
>
Și creați două instanțe ale clasei:
static void Principal (șir [] args)
//
Animale de câine = Animale noi ();
Animale pisică = Animale noi ("Jonny Catsvill");
Console.ReadKey ();
Următorul text va apărea în consola:
Nu există nume de animal
Numele animalului este. Jonny Catsvill
Dar, acestea sunt doar exemple simple, de fapt, constructorii de repornire sunt folositori, de exemplu, pentru a seta valori standard pe câmpuri și nu pentru a duplica același cod.
De exemplu, unul dintre constructorii supraîncărcați poate provoca reîncărcarea unei alte copii a copiei.
șir protejat animal_name;
publice Animale (). acest lucru ("Kvon Cho Wong")
<
>
public Animale (numele șirului)
<
animal_name = nume;
Console.WriteLine ("Numele animalului este" + nume);
>
public virtual void Print_Name ()
<
//
Console.WriteLine ("Numele animalului este." + Animal_name);
>
>
Cu acest apel:
static void Principal (șir [] args)
//
Animale de câine = Animale noi ();
Animale pisică = Animale noi ("Jonny Catsvill");
Console.ReadKey ();
Afișează următorul text:
Numele animalului este. Kvon Cho Wong
Numele animalului este. Jonny Catsvill
Dacă vă întrebați dacă corpul constructorului "gol" va fi executat, atunci răspunsul la această întrebare este, da, va fi, deoarece această construcție funcționează pe principiul moștenirii.
Asta este, atunci când creați o instanță a clasei Animale și nu treceți nimic în parametrii săi, această instanță o numește la sine și își numește propria metodă, dar trece valoarea standard, adică se numește copia supraîncărcată.
Și după ce copia supraîncărcată și-a terminat lucrarea, controlul va reveni din nou la constructorul "gol", iar corpul său va fi executat.
Rezumați articolul.
Iată un exemplu interesant.
Cu tine erai Pruiler. codarea cea mai bună și mai plăcută
Trimiteți-le prietenilor: