DANIELA ALEXANDRA CRIŞAN

conf. univ. dr.

LIMBAJE DE PROGRAMARE II

PROGRAMAREA ORIENTATĂ OBIECT IN LIMBAJUL C#

Obiective curs

Dezvoltarea conceptelor de programare în limbajul C# . Programarea

orientată obiect. Platforma .Net și dezvoltarea aplicațiilor Windows

Bibliografie obligatorie:

1. Crișan D.A., Materiale didactice publicate pe site-ul universității;

2. Crișan D.A., Programarea aplicațiilor folosind limbajul C# și
platforma .NET, volumul II. Programarea Orientata Obiect , Ed
Prouniversitaria;
3. Nita si Co, Introducere în .NET Framework , suport de curs
Microsoft, 2008;

1
D.A.Crisan. Limbajul C#. Vol II. Programarea orientată obiect

ATENTIE

Scopul acestui document este de structura materia predata

in cadrul orelor de curs si seminar. Invatarea materiei,
exclusiv pe baza acestui document, reprezinta o abordare
superficiala!

2
 CAPITOLUL 1. CLASE ȘI OBIECTE

Cuprins:
CLASE ȘI OBIECTE ..........................................................................4
SUPRAÎNCĂRCAREA OPERATORILOR. CONVERSII CE
IMPLICĂ OBIECTE ALE CLASELOR. INDEXATORI ................................................14
DERIVAREA CLASELOR...............................................................18
POLIMORFISM ................................................................................22
CLASE ABSTRACTE. INTERFEȚE ...............................................24
CLASE GENERICE ..........................................................................26

3
D.A.Crisan. Limbajul C#. Vol II. Programarea orientată obiect

CLASE ȘI OBIECTE
1.1 Noțiuni generale

Limbajul C # oferă suport complet pentru programarea orientată pe obiecte

(POO). Aceasta este o paradigmă a programării ce are la bază conceptul de
clase și obiecte.

Conceptele fundamentale ale programării orientate obiect sunt:

• încapsularea - un grup de proprietăți, metode și alți membri sunt tratate
ca o singură unitate (obiect al unei clase);
• moștenirea - descrie abilitatea de a crea noi clase bazate pe o clasă
existentă;
• polimorfismul asigură interschimbabilitatea între mai multe clase care
implementează aceleași proprietăți sau metode în diferite moduri.

class Student
{
//câmpuri
string nume;
int gr;
double nota;
//metode
double MarireNota(double bonus){... }
int MutareGrupa (int grupa_noua){... }
}

Student s1 = new Student(), s2 = new Student();

4
 CAPITOLUL 1. CLASE ȘI OBIECTE

Student[] gr618 = new Student[30];

Membrii unei clase sunt calificați cu ajutorul operatorului punct ‘.’ :

s.nume = "Ion";
s.gr = 619;
s.nota = 8.0;
s.MarireNota(1);//s.nota va fi 9.0

1.2 Încapsularea

Modificatorii de acces. Nivelurile de acces

Există următorii modificatori de acces: public, private, protected, internal,

protected internal.

Proprietăți și accesori (getteri, setteri)

Ex1.
public double GetRe() { return re; }
public void SetRe(double _re) { re = _re; }

Complex c1 = new Complex();

c1.SetRe(3);
Console.WriteLine("c1.re = {0}", c1.GetRe());

Ex2.

class Produs
{ private double _pret;
5
D.A.Crisan. Limbajul C#. Vol II. Programarea orientată obiect

public double Pret

{
get { return _pret; }
set
{
if (value > 0) //value=cuvant cheie
_pret = value;
}
}
}

Proprietăți auto-implementate
class Complex
{
public double Re { get; set; }
public double Im { get; se t; }
}

1.3 Metodele unei clase

▪ constructori
▪ destructori
▪ funcții de acces
▪ funcții de prelucrare

1.4 Referința this

6
 CAPITOLUL 1. CLASE ȘI OBIECTE

Metodele nestatice ale unei clase primesc automat un prim parametru

implicit: referința this. Aceasta este încărcată cu adresa obiectului curent,
adică acel obiect care a invocat metoda.

public void Set(/*Complex this ,*/ double _re, double _im)

{
this._re = _re;
this._im = _im;
}

1.5 Constructorii și destructorii

Tipuri de constructori .
▪ Constructori de instanță - au rolul de a inițializa datele obiectului creat,
cu constante sau valori primite ca argument, preluate de la terminal sau
din fișier.
▪ Constructori statici – inițializează datele statice ale clasei și este apelat
înaintea oricărei instanțieri de obiecte ale clasei.
▪ Constructori de copiere (copy-constructor.

Constructorul implicit (default constructor). Dacă constructorul de

instanță nu primește argumente atunci el se numește constructor implicit

Destructorul unei clase este responsabil cu distrugerea instanței curente

class Complex
{
public double re, im;
public Complex(double re = 0, double im = 0)
7
D.A.Crisan. Limbajul C#. Vol II. Programarea orientată obiect

{
this.re = re; this.im = im;
Console.WriteLine("constructor de instanta: {0}", this);
}

public Complex(Complex that)

{
re = that.re; im = that.im;
Console.WriteLine("constructor de copiere: {0}", this);
}

~Complex()
{
Console.WriteLine("destructor: {0}", this);
}
public override string ToString()
{
return string.Format("{0:N}+i*({1:N})", re, im);
}
}

1.6 Clase, atribute și metode statice. Constructori statici

1.6.1 Clase, atribute și metode statice

Atribute statice. există într-un singur exemplar, comun tuturor obiectelor

clasei respective
Metode statice. referința this nu mai este transmisă
Clasele statice. au numai membri statici, nu pot fi instanțiate.
8
 CAPITOLUL 1. CLASE ȘI OBIECTE

Calificarea membrilor statici

▪ direct, în interiorul clasei (contor);
▪ folosind operatorul . prin asociere cu clasa (Student.contor,
Student.GetContor()).

Constructori statici – Un constructor static este apelat înaintea oricărei

instanțieri de obiecte ale clasei sau oricărei referiri de atribut static.

static Student()
{
_contor = 0;
}

1.7 Atribute constante și atribute readonly

▪ const – valoarea lor este cunoscută de la compilare
class DataCalendaristica{
const int nr_luni=12;
…
}
▪ readonly – sunt inițializate o singură data la execuție, de regulă în
constructor.
class Student
{
public readonly int nr_matricol;
private string _nume;
public Student(int nr_matricol, string nume="Neinitializat")
{
9
D.A.Crisan. Limbajul C#. Vol II. Programarea orientată obiect

this.nr_matricol = nr_matricol;
this._nume = nume;
}
}

1.8 Metode extinse

namespace ConsoleApplication1
{
class Program
{
static void Main(string[] args)
{
int[] V1 = { 1, 3, 5, 7, 9 };
Console.WriteLine("Medie = " + V1.Medie());

int[] V2 = { 1, 2 };
Console.WriteLine("Medie = " + V2.Medie());

Console.ReadKey();
}
}

public static class VectorOperatii

{
public static double Medie(this int[] v)
{
double m = 0.0;
foreach (int x in v)
m += x;
10
 CAPITOLUL 1. CLASE ȘI OBIECTE

return m / v.Length;
} } }

1.9 Evenimente și delegați

Evenimentele permit unei clase sau unor obiecte să notifice alte clase sau
obiecte atunci când are loc ceva care prezintă interes pentru ele.

TextBox textBox1;

textBox1.TextChanged+=new System.EventHandler(textBox1_TextChanged);

private void textBox1_TextChanged(object sender, EventArgs e)

{
TextBox tb = sender as TextBox;
Console.WriteLine("{0} - {1} caractere", tb.Text, tb.Text.Length);
}

1.10 Clase incluse

O clasă poate conține printre câmpurile sale alte clase.

class Profesor
{
public string numeProfesor;
}

class Student

11
D.A.Crisan. Limbajul C#. Vol II. Programarea orientată obiect

{
string numeStudent; int nota;
Profesor profesorCoordonatorLicenta;
}

1.11 Clase anonime

var obClasaAnonima = new { i = 9, s = "abc" };

Console.WriteLine(obClasaAnonima.i + " " + obClasaAnonima.s);

1.12 Clase parțiale

• fișierul Form1.Designer.cs – conține codul sursă pentru controalele

grafice (partea de design):
namespace WindowsFormsApplication1
{
partial class Form1
{… }
}

• fișierul Form1.cs – conține codul sursă cu definițiile membrilor clasei

(logica form-ului):

using System;

namespace WindowsFormsApplication1
{
public partial class Form1 : Form
12
 CAPITOLUL 1. CLASE ȘI OBIECTE

{
public Form1()
{
InitializeComponent();
}

private void Form1_Load(object sender, EventArgs e)

{
toolStripComboBox1.SelectedIndex = 0;
}
}
}

13
D.A.Crisan. Limbajul C#. Vol II. Programarea orientată obiect

SUPRAÎNCĂRCAREA OPERATORILOR.
CONVERSII CE IMPLICĂ OBIECTE ALE CLASELOR.
INDEXATORI

2.1 Supraîncărcarea operatorilor. Aspecte generale

<modif acces> static <tip_intors> operator <simbol> (<lista_parametri_formali>)

Complex c1 = new Complex(3, 5),

c2 = new Complex(7, 9),
c = c1+c2;

public static Complex operator +(Complex c1, Complex c2)

{
return new Complex(c1.re + c2.re, c1.im + c2.im);
}

public static Complex operator +(Complex c, double ct)

{
return new Complex(c.re + ct, c.im);
}

public static Complex operator +(double ct, Complex c)

{ return c + ct; }

Supraîncărcarea operatorilor de incrementare/decrementare (++ și --)

static public Student operator++(Student s)

{
14
 CAPITOLUL 2. SUPRAÎNCĂRCAREA OPERATORILOR. CONVERSII CE IMPLICĂ OBIECTE ALE
CLASELOR. INDEXATORI
return new Student(s._nume, s._grupa+1, s._nota);
}

2.2 Conversii ce implică obiecte ale claselor

▪ Conversie de la un tip de date predefinit către o clasă

Complex c=new Complex();

c=3.0; //conversie de la un double (3.0) la clasa Complex, c va fi 3.0+i*0.0

public static implicit operator Complex (double d)

// conversie implicita de la double la Complex
{
return new Complex(d, 0);
}

▪ Conversie de la o clasă către un tip de date predefinit

Complex c=new Complex(3.0, 5.0);

double d;
d = (double)c;// conversie de la obiectul c la numărul real d, prin extragerea părții
reale, d va fi 3.0

public static explicit operator double(Complex c)

{
return c.re;
}

15
D.A.Crisan. Limbajul C#. Vol II. Programarea orientată obiect

2.3 Indexatori

class Student
{
private string _nume;
private int _grupa;
private List<double> _note;

public Student(string nume, int grupa, List<double> note)

{
_nume = nume;
_grupa = grupa;
_note = note;
}
public override string ToString()
{
string s = string.Format("studentul {0} din grupa {1} are situatia:", _nume,
_grupa);
foreach (double nota in _note)
s += String.Format("{0:N} ",nota);
return s;
}

public double this[int i]//indexator

{
get
{
if (i>=0 && i<_note.Count)
return _note[i];
16
CAPITOLUL 2. SUPRAÎNCĂRCAREA OPERATORILOR. CONVERSII CE IMPLICĂ OBIECTE ALE
CLASELOR. INDEXATORI
else return -1;
}
set
{
if (i >= 0 && i < _note.Count)
_note[i] = value;
}
}
}

17
D.A.Crisan. Limbajul C#. Vol II. Programarea orientată obiect

DERIVAREA CLASELOR

3.1 Clase derivate. Moștenire

3.2 Constructorii și destructorii în contextul derivării claselor

class Student
{
string nume;
int grupa;

public Student(string nume = "Neinitializat", int grupa = 0)

{
this.nume = nume;
this.grupa = grupa;
Console.WriteLine("Constructor clasa Student:" + this.nume + "," +
this.grupa);
}

public Student(Student s)
{
this.nume = s.nume;
this.grupa = s.grupa;

18
 CAPITOLUL 3. DERIVAREA CLASELOR

Console.WriteLine("Constructor copiere clasa Student:" + this.nume + ","

+ this.grupa);
}

~Student()
{
Console.WriteLine("Destructor clasa Student:" + this.nume + "," +
this.grupa);
}
}

class Bursier : Student

{
double bursa;
public Bursier(string nume, int grupa, double bursa = 0)
:base(nume,grupa)
{
this.bursa = bursa;
Console.WriteLine("Constructor clasa Bursier: +" + this.bursa);
}
public Bursier(Student s, double bursa = 0)
: base(s)
{
this.bursa = bursa;
Console.WriteLine("Constructor 2 clasa Bursier: +" + this.bursa);
}

~Bursier()
{
Console.WriteLine("Destructor clasa Bursier: + " + this.bursa);
}
}

static void Main(string[] args)

19
D.A.Crisan. Limbajul C#. Vol II. Programarea orientată obiect

{
Bursier b = new Bursier("ionel", 616, 200);
}

Aplicația afișează:

Constructor clasa Student:ionel,616

Constructor clasa Bursier: +200
Destructor clasa Bursier: + 200
Destructor clasa Student:ionel,616

3.3 Suprascrierea metodelor

public new void Afisare()

{
base.Afisare();
Console.Write(" si are bursa in cuantum de " +
this.bursa + " lei");
}

Suprascrierea metodei ToString

public override string ToString()

{
return "Studentul " + this.nume + " este in grupa " + this.grupa;
}

3.4 Conversii între clase ierarhizate

▪ conversia de la clasa derivată D către clasa de bază B:

20
 CAPITOLUL 3. DERIVAREA CLASELOR

Bursier b = new Bursier("ionel", 616, 200);

Student s = b;
s.Afisare();
va afișa
Studentul ionel este in grupa 616

▪ conversia de la clasa de bază B către clasa derivată D.

B b; D d;
d=b; //conversie de la B la D

public Bursier(Student s, double bursa = 0)

: base(s)// s-a folosit copy-constructorul clasei Student
{
this.bursa = bursa;
}

3.5 Clase sigilate (sealed)

O clasă sealed nu mai poate fi derivată, ea este clasă terminală în ierarhia de

clase.
class B{ }
sealed class D : B { }
//class DD :D { }//nu poate fi derivata dintr-o clasa sealed

21
 POLIMORFISM
4.1 Metode virtuale

• early binding (legare timpurie).

• late binding (legare târzie) - virtual

class Student
{
string nume;
int grupa;

public Student(string nume = "Neinitializat", int grupa = 0)

{
this.nume = nume;
this.grupa = grupa;
}

public virtual void Afisare()

{
Console.Write("Studentul " + this.nume + " este in grupa " +
this.grupa);
}
}

class Bursier : Student

{
double bursa;
public Bursier(string nume, int grupa, double bursa = 0) :
base(nume, grupa)
{
this.bursa = bursa;
}
public override void Afisare()
{
base.Afisare();
Console.Write(" si are bursa in cuantum de " + this.bursa + " lei");
}

22
 0

CLASE ABSTRACTE. INTERFEȚE

}

class Program
{
static void Main(string[] args)
{
Bursier b = new Bursier("ionel", 616, 200);
Student s = b;
s.Afisare();

Console.ReadKey();
}
}

Se va afișa:
Studentul ionel este in grupa 616 si are bursa in cuantum de 200 lei

4.2 Metode sigilate

Dacă dorim ca o metodă virtuală să nu mai fie suprascrisă în clasele derivate,
o declarăm ca sealed:
class B {
protected virtual void F1() { Console.WriteLine("B.F1"); }
protected virtual void F2() { Console.WriteLine("B.F2"); }
}
class D : B {
sealed protected override void F1() { Console.WriteLine("D.F1"); }
protected override void F2() { Console.WriteLine("D.F2"); }
}
class DD : D {
//protected override void F1() { Console.WriteLine("DD.F1"); }
//eroare - suprascriere nepermisa
protected override void F2() { Console.WriteLine("DD.F2"); }
}

23
 CLASE ABSTRACTE. INTERFEȚE
5.1 Metode abstracte
O metodă abstractă –

• nu are definiție (corp) ci numai declarație (semnătură).

• existența ei obligă toate clasele derivate să creeze versiuni proprii ale
acestei funcții, să o suprascrie.
• selectata la execuție.
• poate fi conținută numai într-o clasă abstractă.

5.2 Clase abstracte

• nu poate avea instanțe;

24
 0

CLASE ABSTRACTE. INTERFEȚE

5.3 Interfețe
5.3.1 Utilizarea interfeței IComparable

class Student:IComparable

public int CompareTo(Object b)

{
return _nota.CompareTo((b as Student)._nota);
}

5.3.2 Crearea unei interfețe proprii

Grupul de programatori

public class Student : Persoana, IProgrameaza

public class Inginer : Angajat, IProgrameaza

public interface IProgrameaza

{
void Programeaza();
}

25
26
 CLASE GENERICE
6.1 Programarea generică
Clasa generică Mulțime

public class Multime<T> : List<T> where T : IComparable

{
public override string ToString()
{
string s = "{";
foreach (T elem in this)
s += elem + " ";
s += '}';
return s;
}
static public Multime<T> operator +(Multime<T> m, T elem)
{//adugare element in multime
Multime<T> temp = new Multime<T>();
temp.AddRange(m);
temp.Add(elem);
return temp;
}
static public Multime<T> operator +(Multime<T> m1, Multime<T>
m2)
{//reuniune doua multimi
Multime<T> temp = new Multime<T>();
temp.AddRange(m1);
temp.AddRange(m2);
return temp;
}
//
}

27