Programarea Orientată pe Obiecte – Principii și Abstractizarea 17
1. Obiectivele lecției:
- Să înțeleagă cele patru principii fundamentale ale programării orientate pe obiecte (POO).
- Să exploreze conceptul de abstractizare și aplicarea acestuia în proiectarea software.
- Să implementeze exemple practice pentru a înțelege abstractizarea.
2. Principiile fundamentale ale POO
1. Încapsularea
- Definiție:
Gruparea datelor (atribute) și a funcțiilor care operează asupra acestor date (metode) într-o singură entitate numită clasă.
Atributele sunt protejate de accesul direct folosind modificatori de acces (private, protected, public). - Avantaje:
- Protecția datelor.
- Control asupra modului în care datele sunt accesate sau modificate.
- Exemplu:
class ContBancar {
private:
double sold;
public:
void depune(double suma) {
sold += suma;
}
double obtineSold() {
return sold;
}
};
2. Abstractizarea
- Definiție:
Procesul de a ascunde detaliile implementării și de a expune doar funcționalitatea esențială utilizatorului. - Exemplu real:
O mașină – utilizatorul folosește pedala de accelerație pentru a crește viteza fără a înțelege cum funcționează motorul intern. - Avantaje:
- Simplifică complexitatea.
- Reduce dependența utilizatorului de implementare.
- Exemplu:
class Vehicul {
public:
virtual void porneste() = 0; // Metodă pur abstractă
};
class Masina : public Vehicul {
public:
void porneste() override {
cout << „Mașina a pornit.” << endl;
}
};
int main() {
Vehicul* v = new Masina();
v->porneste();
return 0;
}
3. Moștenirea
- Definiție:
Permite crearea unei noi clase (clasă derivată) bazată pe o clasă existentă (clasă de bază), moștenind atributele și metodele acesteia. - Avantaje:
- Reutilizarea codului.
- Crearea de ierarhii logice.
- Exemplu:
class Animal {
public:
void mananca() {
cout << „Animalul mănâncă.” << endl;
}
};
class Pisica : public Animal {
public:
void miauna() {
cout << „Pisica miaună.” << endl;
}
};
4. Polimorfismul
- Definiție:
Capacitatea de a utiliza aceeași interfață pentru diferite implementări. - Tipuri:
- Polimorfism static: Suprasarcina funcțiilor (funcții cu același nume, dar parametri diferiți).
- Polimorfism dinamic: Suprascrierea metodelor în clase derivate.
- Exemplu de polimorfism dinamic:
class Animal {
public:
virtual void sunet() {
cout << „Animalul face un sunet.” << endl;
}
};
class Caine : public Animal {
public:
void sunet() override {
cout << „Câinele latră.” << endl;
}
};
int main() {
Animal* a = new Caine();
a->sunet(); // Apelează metoda din clasa Caine
return 0;
}
3. Abstractizarea în detaliu
1. Clase abstracte
- Definiție:
O clasă care nu poate fi instanțiată direct și care conține metode pur abstracte (declarații fără implementare).
Metodele pur abstracte sunt definite folosind = 0. - Exemplu:
class Forma {
public:
virtual void desen() = 0; // Metodă pur abstractă
};
class Cerc : public Forma {
public:
void desen() override {
cout << „Desenez un cerc.” << endl;
}
};
int main() {
Forma* f = new Cerc();
f->desen();
return 0;
}
2. Interfețe (în alte limbaje, similare cu clase abstracte în C++)
- Definiție:
Reprezintă un contract care definește metodele pe care o clasă derivată trebuie să le implementeze. - Exemplu:
class Calcul {
public:
virtual int calculeaza(int a, int b) = 0;
};
class Adunare : public Calcul {
public:
int calculeaza(int a, int b) override {
return a + b;
}
};
int main() {
Calcul* c = new Adunare();
cout << „Rezultatul: ” << c->calculeaza(5, 3) << endl;
return 0;
}
4. Avantajele abstractizării
- Simplificare:
Codul este mai ușor de înțeles și utilizat. - Flexibilitate:
Permite schimbarea implementării fără a afecta utilizatorii. - Extensibilitate:
Ușurează adăugarea de noi funcționalități fără a modifica codul existent.
5. Exemple practice
Exemplu 1: Aplicație pentru forme geometrice
#include <iostream>
using namespace std;
class Forma {
public:
virtual double calculeazaAria() = 0; // Metodă pur abstractă
};
class Dreptunghi : public Forma {
private:
double lungime, latime;
public:
Dreptunghi(double l, double L) : lungime(l), latime(L) {}
double calculeazaAria() override {
return lungime * latime;
}
};
class Cerc : public Forma {
private:
double raza;
public:
Cerc(double r) : raza(r) {}
double calculeazaAria() override {
return 3.14 * raza * raza;
}
};
int main() {
Forma* dreptunghi = new Dreptunghi(5, 10);
Forma* cerc = new Cerc(7);
cout << „Aria dreptunghiului: ” << dreptunghi->calculeazaAria() << endl;
cout << „Aria cercului: ” << cerc->calculeazaAria() << endl;
delete dreptunghi;
delete cerc;
return 0;
}
Exemplu 2: Sistem de plăți
#include <iostream>
using namespace std;
class Plata {
public:
virtual void proceseazaPlata(double suma) = 0;
};
class PlataCard : public Plata {
public:
void proceseazaPlata(double suma) override {
cout << „Plata de ” << suma << ” lei a fost procesată prin card.” << endl;
}
};
class PlataCash : public Plata {
public:
void proceseazaPlata(double suma) override {
cout << „Plata de ” << suma << ” lei a fost procesată prin cash.” << endl;
}
};
int main() {
Plata* plata = new PlataCard();
plata->proceseazaPlata(150.5);
plata = new PlataCash();
plata->proceseazaPlata(200);
return 0;
}
6. Activități practice pentru elevi
- Creați o clasă abstractă Animal cu o metodă pur abstractă sunet. Implementați clasele Caine și Pisica.
- Realizați un program care modelează vehicule (clasă abstractă Vehicul cu metode pentru pornire și oprire).
- Scrieți un program care implementează un sistem de management al plăților utilizând abstractizarea.
7. Concluzie
- Abstractizarea este un concept esențial în programarea orientată pe obiecte care simplifică interacțiunea utilizatorului cu sistemul.
- Prin separarea detaliilor de implementare, codul devine mai ușor de întreținut și extins.
- Practica și utilizarea claselor abstracte și a polimorfismului ajută la construirea de aplicații robuste și scalabile.