Metodele sunt funcțiii membru ale unei clase. Pot fi statice
(metode de clasă) sau nestatice (metode de instanță).
Pot exista mai multe metode diferite cu acelasi nume intr-o
clasa, cu conditia sa difere lista de parametri prin numar sau tip.
Legarea uneia sau alteia dintre aceste funcții omonime se face la momentul compilării (legare timpurie), pe baza listei de parametri: se va lega funcția a cărei semnătură se potrivește cel mai bine cu lista de parametri actuali. Acest mecanism se numește polimorfism ad-hoc.
Legarea uneia sau alteia dintre aceste funcții omonime se face la momentul compilării (legare timpurie), pe baza listei de parametri: se va lega funcția a cărei semnătură se potrivește cel mai bine cu lista de parametri actuali. Acest mecanism se numește polimorfism ad-hoc.
Clasele derivate pot redefini metode ale clasei de baza,
pastrand numarul si tipul parametrilor, cu conditia aplicarii modificatorilor virtual
(aplicat metodei din superclasa) si override (aplicat metodei din
clasa derivata). Mecanismul este valabil si pentru constructori. În cazul acesta, funcția nu se leagă de către compilatorul C# ci de către sistemul .NET (Windows) la momentul execuției (legare întârziată, la run-time), pe criteriul identificării tipului obiectului al cărui membru este metoda apelată. Acesta este polimorfism de moștenire.
Clasa Copil are doi
constructori: unul fara parametri si unul cu 1 parametru string.
Clasa derivata Fetita
redefineste ambii constructori.
Clasa derivata Baiat nu defineste nici un consructor, ca
urmare se apeleaza constructorul implicit al clasei fara parametri.
namespace Lectia9
{
public class Copil
{
protected string nume; //data accesibila
numai in interiorul
//clasei si a claselor derivate
public const int nr_max = 10; //constanta
public static int nr_copii = 0; //camp
simplu (variabila)
static Copil[] copii = new Copil[nr_max]; //camp de tip
//tablou de referinte
tip Copil alocat static, maxim 10 elemente
public static void adaug_copil(Copil c) //metodă cu parametru referinta Copil
{
copii[nr_copii++] = c;
if (nr_copii == nr_max)
throw new Exception("Prea multi
copii");
}
public static void afisare() //metodă
{
Console.WriteLine("Sunt {0}
copii:", nr_copii);
for (int i = 0; i < nr_copii; i++)
Console.WriteLine("Nr.{0}.
{1}", i + 1, copii[i].nume);
}
public Copil() //constructorul fara
parametri ai clasei
{
Console.Write("Nume {0}
", nr_copii+1);
nume = Console.ReadLine();
}
public Copil(string s) //constructor cu parametru
{
nume = s;
}
}
class Baiat : Copil { }
class Fetita : Copil
{
public Fetita(string s) : base(s)
//base semnifica faptul ca se face mai intai apel la constructorul
//din
clasa de baza, apoi se inlocuieste numele cu „Fetita „+nume
}
nume = "Fetita
" + nume;
}
public Fetita():base()
{ }
}
class Program
{
public static void Main()
{
Fetita f = new Fetita();
Copil.adaug_copil(f);
//apel la metoda statica
(metoda de clasa)
//referinţa noului obiect se
memorează în tabloul static copii
//(caracteristic clasei) şi
se incrementează data statică nr_copii
Baiat b = new Baiat();
Copil.adaug_copil(b);
Copil c = new Copil();
Copil.adaug_copil(c);
Copil.afisare(); //se afişează
o listă cu numele celor 3 copii
Console.ReadKey();
}
}
}
Mostenirea
si suprascrierea metodelor nestatice ale
clasei Copil in clasele derivate
In programul de mai sus se adauga in clasa de baza metodele
se_joaca() cu modificatorul virtual si se_joaca(sting s) fara virtual. In clasa derivata Fetita se
suprascrie metoda se_joaca() cea virtuala.
public class Copil
{
protected string nume;
// … constructorii
public virtual void se_joaca( ) //virtual –> asadar functia se poate
{ //suprascrie in clasele derivate, dar nu
obligatoriu. In absenta lui virtual nu s-ar putea suprascrie.
Console.WriteLine("{0} se joaca.", this.nume);
}
// urmează un polimorfism ad-hoc: definirea unei funcții omonime cu altă semnătură
public void se_joaca(string jucaria) //supradefinirea metodei
public void se_joaca(string jucaria) //supradefinirea metodei
{ //se_joaca
Console.WriteLine("{0} se joaca cu {1}.",this.nume,jucaria);
}
...
}
class Fetita: Copil
{
public override void se_joaca( ) //suprascriere = override a unei metode virtuale din clasa de
baza Copil. Apelul acestei metode se va rezolva la run-time - polimorfism de moștenire
{
Console.WriteLine("{0} plimba pisica.", this.nume);
}
}
...
In metoda Main() se adauga
apelul catre functiile se_joaca, atat cea suprascrisa (fara parametru) cat si
cea nesuprascrisa (cu parametru),
plecand de la un obiect de tip Fetita si de la un obiect de tip Baiat. Functia
apelata este diferita, de la caz la caz.
Fetita f = new Fetita(
);
f.se_joaca("pisica"); // Andreea se joaca cu pisica – apel metoda cu
parametru din clasa de baza Copil. Legare timpurie. Este un apel nepolimorfic către o metodă moștenită.
f.se_joaca( ); // Andreea plimba pisica – apel metoda suprscrisa din clasa
derivata Fetita. Legare întârziată. Apel către o funcție moștenită supraîncărcată = polimorfică.
Baiat b = new Baiat
( );
b.se_joaca("calculatorul"); //Andrei
se joaca cu calculatorul – apel metoda cu parametru din clasa de baza
b.se_joaca( ); // Andrei se joaca – apel metoda
fara parametru din clasa de baza. Toate apelurile către metode ale clasei de bază sunt legate timpuriu. Moștenire fără polimorfism.
Evidențierea legării întârziate a metodelor supraîncărcate ale clasei derivate.
Adaugam in metoda Main() urmatoarele instructiuni:
Copil d = f;
// referinta d de tip Copil refera un obiect de tip Fetita.
d.se_joaca();
// Apel catre functia supraincarcata se_joaca() a subclasei Fetita. Legarea apelului se face la run-time catre //functia clasei Fetita, deoarece abia atunci se identifica tipul obiectului referit de d in urma atribuirii d=f.
Rezultatul este ca se va afisa la consola textul Andreea plimba pisica.
Evidențierea legării întârziate a metodelor supraîncărcate ale clasei derivate.
Adaugam in metoda Main() urmatoarele instructiuni:
Copil d = f;
// referinta d de tip Copil refera un obiect de tip Fetita.
d.se_joaca();
// Apel catre functia supraincarcata se_joaca() a subclasei Fetita. Legarea apelului se face la run-time catre //functia clasei Fetita, deoarece abia atunci se identifica tipul obiectului referit de d in urma atribuirii d=f.
Rezultatul este ca se va afisa la consola textul Andreea plimba pisica.
