38
POO POO 1
POOPOO
1
I. Principiile OOP
II. Clase – generalitati
III. Metode
IV. Constructori si destructori
V. Supraincarcarea operatorilor
VI. Proprietati
VII.Mosteniri
VIII. Polimorfism
IX. Evenimente si delegari
X. Clase si functii generice
2
Tipuri de date abstracte (ADT) – entitate caracterizată printr-o colecţie de date şi un ansamblu de operaţii aplicabile acestor date.
Interfaţa unui ADT – date şi operaţii care sunt accesibile din afara tipului
Instanţă a unui ADT – o concretizare a tipului respectiv
Tip de date obiectual – tip de date care implementează un ADT.
Exemplu: class, struct, object
Obiect – instanţă a unui tip de date obiectual
Metode – operaţii implementate în cadrul tipului de date
Membri – date şi metode care definesc tipul de date de tip instanţă – caracteristici fiecărui obiect de tip clasă – caracteristici clasei (static); pot fi referiţi fără a crea instanţe
Constructor – metoda apelată la crearea unei instanţe
Destructor – metoda apelată la desfiinţarea unei instanţe
3
1. Abstractizarea – modelrea unor clase care pastreaza trasaturile esentiale ale obiectului real care sunt suficiente pentru realizarea scopului propus (membrii clase definesc aceste trasaturi)
2. Încapsularea - protejarea clasei - definirea nivelului de acces la membrii unei clase.
3. Moştenire (Derivare )- operaţia de extindere sau specializare a comportamentului unei clase existente, prin definirea unei clase noi (subclasă, clasă derivată, clasă descendentă) care:-moşteneşte membrii clasei de bază-redefineşte unii membri-adaugă noi membri
4. PolimorfismSemnătura (amprenta) unei funcţii – ansamblul format din numele funcţiei şi lista sa de parametri.Supraîncărcarea - definirea mai multor funcţii sau metode, cu acelaşi nume dar care trebuie să difere prin parametri -număr / tip).Polimorfism - facilitate pentru clase derivate
4
Modificator de acces la nivel de clasă
Explicaţii Clase cărora li se poate aplica
public acces nelimitat clase interioareclase conținute în spații de nume
internal acces doar în clasa sau spațiul de nume care o cuprinde
clase interioareclase conținute în spații de nume (modificator implicit)
protected acces în clasa curentă sau în cele derivate (chiar dacă clasa derivată face parte din alt spațiu de nume)
clase interioare
private acces limitat la clase interioare; clase interioare (modificator implicit)
protected internal
acces în spațiul de nume curent în clasa conținătoare sau în tipurile derivate din clasa conținătoare
clase interioare
new clasa conține un membru cu același nume care este moștenit;
clasele interioare
sealed clasa nu poate fi moștenită clasă interioară sau nu
abstract clasa nu poate fi instanțiată clase interioare sau conținute înspații de nume;
5
Modificator de acces la nivel de membri
Accesibilitate membri
public nelimitat;
internal doar în clasa sau spațiul de nume care îi cuprinde
protected în clasa curentă şi în cele derivate (chiar dacă clasa derivată face parte din alt spațiu de nume)
private doar în clasa curentă; (modificator implicit de acces)
protected internal în spațiul de nume curent, în clasa curentă şi în clasele derivate
6
1. Definirea clasei[atribut] [modificatorAcces] class [numeClasa][:clasaBaza ]{
…. definire membrii clasei (date, metode) ….}Exemplu:
class Persoana{
public int varsta;public string nume;public void ScrieNume();
}2. Crearea obiectelorNumeClasa obiect;obiect = new NumeClasa();sau NumeClasa obiect = new NumeClasa();Exemplu:
Persoana elev1 = new Persoana();Persoana elev2 = new Persoana();
3. Accesul la membrii clasei obiect.MembruExemplu:
elev1.varsta=20; elev2.varsta=49;elev2.ScrieNume();
7
8
Exemplu – numere complexe
namespace ClaseComplex{ class Complex { public double real; public double imaginar; }
class Program { static void Main(string[] args) { Complex z = new Complex(); z.real = 2; z.imaginar = 3; Console.Write(z.real + " i" + z.imaginar); Console.ReadKey(); } }}
9
namespace ClaseComplex
{
class Complex
{
double real;
double rmaginar;
public void Citeste()
{
real=double.Parse(Console.ReadLine());
imaginar=double.Parse(Console.ReadLine());
}
public void Scrie()
{
Console.WriteLine(real + " i" + imaginar);
}
public double Modul()
{
return Math.Sqrt(real*real+imaginar*imaginar);
}
}
10
class Program { static void Main(string[] args) { Complex z = new Complex(); z.Citeste(); z.Scrie(); Console.Write(z.Modul()); Console.ReadKey(); } }}
Observatie – referinta la obiectul curent:
this.Membru
Definire
[Modificatori de acces] TipRezultat NumeMetoda (lista de parametri formali)
{
codul metodei
}
Apel
NumeMetoda(lista parametri actuali)
Parametri:
1. la definire
-de intrare: TipParametru numeParametruFormal
-de intrare – iesire: ref TipParametru numeParametruFormal
-de iesire: out TipParametru numeParametruFormal
2. la apel
-de intrare: numeParametruActual sau valoare
-de intrare – iesire: ref numeParametruActual
-de iesire: out numeParametruActual
11
namespace CMMDC
{
class Numere
{
public int IntrareCMMDC(int a, int b)
{
while (a != b)
if (a > b)
a = a - b;
else
b = b - a;
return a;
}
}
12
class Program { static void Main(string[] args) { Numere nr = new Numere(); int x, y, cmxy; x = 21; y = 15; cmxy = 0; cmxy = nr.IntrareCMMDC(x,y); Console.WriteLine("Dupa apel x={0}, y={1}, cmxy={2}", x, y, cmxy); }}
namespace CMMDC
{
class Numere
{
public void IesireCMMDC(int a, int b, out int cm)
{
while (a != b)
if (a > b)
a = a - b;
else
b = b - a;
cm=a;
}
}
13
class Program { static void Main(string[] args) { Numere nr = new Numere(); int x, y, cmxy;
x = 21; y = 15; cmxy = 0; nr.IesireCMMDC(x, y, out cmxy); Console.WriteLine("Dupa apel x={0}, y={1}, cmxy={2}", x, y, cmxy);
} }}
namespace CMMDC
{
class Numere
{
public void IntrareIesireCMMDC(ref int a, int b)
{
while (a != b)
if (a > b)
a = a - b;
else
b = b - a;
}
}
14
class Program { static void Main(string[] args) { Numere nr = new Numere(); int x, y, cmxy; x = 21; y = 15; cmxy = 0; nr.IntrareIesireCMMDC(ref x, y); Console.WriteLine("Dupa apel x={0}, y={1}, cmxy={2}", x, y, cmxy);
Console.ReadKey(); } }}
namespace OverloadingFractie
{
class Fractie
{
public double numarator;
public double numitor;
public void Aduna(double nr)
{
numarator = numarator+numitor*nr;
}
public void Aduna(Fractie f)
{
numarator = numarator*f.numitor + numitor * f.numarator;
numitor = numitor * f.numitor;
}
public void Afisare()
{
Console.WriteLine("{0}/{1}", numarator, numitor);
}
}
15
class Program { static void Main(string[] args) { Fractie f1 = new Fractie(); Fractie f2 = new Fractie(); double numar;
f1.Numarator = 1; f1.Numitor = 2; Console.WriteLine("Initial, f1 este"); f1.Afisare(); numar = 100; f1.Aduna(numar); Console.WriteLine("Dupa adunarea nr real {0}, f1 este: ",numar); f1.Afisare();
f1.Numarator = 1; f1.Numitor = 2; f2.Numarator = 2; f2.Numitor = 5; Console.WriteLine("Initial, f1 este"); f1.Afisare(); Console.WriteLine("Initial, f2 este"); f2.Afisare(); f1.Aduna(f2); Console.WriteLine("Dupa adunarea fractiei f2, f1 este: "); f1.Afisare(); Console.ReadKey(); } }}
Exemplu:namespace Complex{
class Complex{
private int re; private int im;public Complex(){ re=0; im=0;}public Complex(int i, int j) //constructor cu doi parametri{ re = i; im = j;}public void Afis(){ Console.WriteLine(re + "+" + im + "i");}
}class Program{
static void Main(string[] args){
Complex c = new Complex(1, 2); c.Afis();Complex d = new Complex(); d.Afis();Console.ReadLine();
}}
}16
Se apeleaza automat la crearea instantei clasei
Caracteristici•implementează acţiunile necesare distrugerii unei instanţe a clasei•este apelat automat•într-o clasă există un singur destructor•numele destructorului: ~NumeClasa•Nu are parametri şi nici modificator de acces•nu poate fi moştenit.
Sintaxa~numeClasa(){corp_destructor}
17
Exemplu:namespace Mesaj{
class Program{
static void Main(string[] args){
Mesaj a = new Mesaj();Console.ReadLine();
}class Mesaj{
public Mesaj(){
Console.WriteLine("Apel constructor");}~Mesaj(){
Console.WriteLine("Apel destructor");}
}}
}18
Sintaxa
public static TipRezultat operator op (lista parametri){…}
op poate fi +, -, *, ++ etc.
19
class Fractie { public double numarator; public double numitor; public static Fractie operator+ (Fractie f1, Fractie f2) { Fractie rez=new Fractie(); rez.numarator = f1.numitor * f2.numarator + f1.numarator * f2.numitor; rez.numitor = f1.numitor * f2.numitor; return rez; }
public static Fractie operator +(Fractie f1, double nr) { Fractie rez = new Fractie(); rez.numarator = f1.numitor * nr + f1.numarator; return rez; }
public void Scrie() { Console.WriteLine(numarator+" / "+numitor); }
}
20
class Program { static void Main(string[] args) { Fractie f1 = new Fractie(); Fractie f2 = new Fractie(); Fractie f3 = new Fractie();
f1.numarator = 1; f1.numitor = 2; f2.numarator = 3; f2.numitor = 5; f3 = f1 + f2; f1.Scrie(); f2.Scrie(); f3.Scrie(); Console.ReadKey();
} }}
Caracteristici
Permit accesul la datele membre - accesori
Sintaxa
class NumeClasa
{ ……
private Tip data;
public Tip Data
{
get
{
return data;
}
set
{ … cod care protejeaza data …..
data=value;
}
}
Acces la camp prin intermediul proprietatii:
obiect.Data
21
22
CaracteristiciO clasă care este moştenită se numeşte clasă de bază sau superclasă, iar o clasă care o
moşteneşte pe aceasta se numeşte clasă derivată, sau subclasă, sau clasă descendentă.
Clasa derivată moşteneşte toate elementele clasei de bază şi-şi adaugă altele proprii.Clasa derivată nu poate să şteargă nici un membru al clasei de bază.Sintaxa:class ClasaDerivata : ClasaDeBaza{…}
ObservatieModificatorul abstract obligă la procesului de derivare (trebuie obligatoriu derivata) Modificatorul sealed se opune la procesului de derivare (e un fel de terminal înierarhia claselor)
23
24
Constructorul clasei derivate trebuie să facă inițializările câmpurilor în conformitate cu parametrii transmiși, chiar dacă o parte din aceste câmpuri provin din clasa de bază.
Întrucât constructorii nu se moștenesc, e nevoie ca în clasa derivată să se facă un apel explicit al constructorului clasei de bază: :base(parametri-efectivi)
Exemplu:
class ClasaDeBaza
{
protected string var;
public ClasaDeBaza(string var) //constructor
{
this.var = var;
}
}
class Derivata : ClasaDeBaza
{
public ClasaDeBaza(string var) : base(var)
{
...
}
}25
O clasă declarată virtuală implică faptul că o metodă implementată în ea poate fi redefinită în clasele derivate.
Doar metodele virtuale ne statice şi/sau private pot fi redefinite într-o clasă derivată. Aceste metode trebuie să aibă aceeaşi signatură (nume, modificator de acces, tip returnat şi parametri).
Pentru declararea unei metode ca fiind virtuală se foloseşte cuvântul cheie virtual.
În clasele derivate se va folosi cuvântul cheie override pentru redefinirea metodei virtuale din clasa de bază.
class ClasaDeBaza
{
public virtual void Metoda()
{
...
}
}
class Derivata : ClasaDeBaza
{
public override void Metoda()
{
...
}
}
26
Pentru a specifica faptul că metoda clasei derivate este o implementare nouă a respectivei metode.
metoda are aceeaşi signatură cu a celei din clasa de bază, dar dorim să menţionăm că este o metodă nouă
class ClasaDeBaza
{
public virtual void Metoda()
{
...
}
}
class Derivata : ClasaDeBaza
{
public new void Metoda()
{
...
}
}
27
28
Caracteristici
realizează comunicarea între obiecte: permit clasei sau obiectelor clasei să facă notificări, adică să anunţe celelalte obiecte asupra unor schimbări petrecute la nivelul stării lor.
Clasa furnizoare a unui eveniment publică (pune la dispoziţia altor clase) acest lucru printr-o declarare event care asociază evenimentului un delegat, adică o referinţă către o funcţie necunoscută căreia i se precizează doar antetul, funcţia urmând a fi implementată la nivelul claselor interesate de evenimentul respectiv.
Tehnica prin care clasele implementează metode (handler-e) ce răspund la evenimente generate de alte clase poartă numele de tratare a evenimentelor.
Un delegat se poate defini şi în afara clasei generatoare de evenimente şi poate servi şi altor scopuri în afara tratării evenimentelor
Sintaxa
Definirea unui event
[atribut][modificatorAcces] even tipDelegat nume
tipReturnat - poate fi orice tip valid în C#, el specificând tipul folosit de accesorii get (tipul valorii returnate) şi set (tipul valorii atribuite).
tipDelegat – este un tip de date, derivat din clasa sigilată Delegate din spaţiul System.
Definirea unui tip delegat:
[atribut][modificatorAcces] delegate tipRezultat nume[listaParametri])
29
Caracteristici
şabloane (templates) sau modele care ajută la reutilizarea codului. Ele descriu clase şi metode care pot lucra într-o manieră uniformă cu tipuri de valori diferite.
permit definirea de funcţionalităţi şi metode care se adaptează la tipurile parametrilor pe
care îi primesc, ceea ce permite construirea unui şablon.
Singura diferenţă faţă de declararea în mod obişnuit a unei clase, este prezenţa caracterelor < şi >, care permit definirea tipului pe care clasa îl va avea, ca şi cum ar fi un parametru al clasei.
La instanţierea clasei trebuie să declarăm tipul datelor utilizate.
Tipurile generice (parametrizate) permit construirea de clase, structuri, interfeţe, delegaţi sau metode care sunt parametrizate printr-un tip pe care îl pot stoca sau manipula.
30
Exemplu Să considerăm clasa Stiva care permite stocarea de elemente. Această clasă are două metode: Push() şi Pop().
public class Stiva<TipElement> //clasa generica
{
private TipElement[] element;
public void Push(TipElement data)
{
// code corespunzator introducerii de elemente
}
public TipElement Pop()
{
// code corespunzator extragerii de elemente
}
}
Stiva <char> StivaMea = new Stiva<char>();
StivaMea.Push("a");
char x = StivaMea.Pop();
31
Scrieti o aplicatie cu numele OOP1, in care definiti clasa Fractie, pentru numere de forma a/b (a,b, reale), si adaugati cate o metoda care sa citeasca si respectiv sa afiseze pe ecran o astfel de fractie, precum si sa calculeze valoarea reala a numarului a/b.
In Main definiti o instanta a acestei clase, cititi si afisati pe ecran o fractie ca instanta a clasei, precum si valoarea reala a fractiei.
32
Scrieti o aplicatie cu numele OOP2, in care definiti clasa Numar, pentru numere naturale si adaugati metode care sa adune o valoare k la numarul respectiv, utilizand parametri de intrare, de intrare-iesire, si iesire.
In Main definiti o instanta a acestei clase, cititi si afisati pe ecran valoarea unei variabile inainte si dupa apelul metodelor mentionate.
33
Scrieti o aplicatie cu numele OOP3, in care definiti clasa Complex, pentru numere de forma a+bi si adaugati doua metode cu numele Aduna, pentru adunarea la nr curent a unui numar real, respectiv a unui alt nr complex.
34
Scrieti o aplicatie cu numele OOP4, in care definiti clasa Masina, care sa memoreze date despre o masina (marca, putere motor). Adaugati destructor si constructori care sa permita definitiile:
Masina m1 = new Masina();
Masina m2=new Masina(“Dacia”);
Masina m3 = new Masina(“Dacia”, 60);
Fiecare constructor si destructorul afiseaza un mesaj.
35
Scrieti o aplicatie cu numele OOP5, in care definiti clasa Complex, care sa memoreze date despre numere complexe. Supradefiniti operatorii + si *, care sa permita operatii de forma
Complex z1=new Complex();
Complex z2=new Complex();
Complex z3=new Complex();
z3=z1+z2;
z3=z1+5;
z3=z1*z2;
z3=z1*5;
36
Scrieti o aplicatie cu numele OOP6, in care definiti clasa Persoana, care sa memoreze date despre o persoana (nume, varsta). Adaugati proprietati (set-get) care sa nu permita setarea varstei negative.
37
Scrieti o aplicatie cu numele OOP7, in care definiti clasa Animal, care sa memoreze date despre un animal (nume, varsta) si clasa Cal, care sa mosteneasca clasa Animal, avand in plus date despre rasa.
38
