Programarea Orientată pe Obiecte – Principii și Moștenirea 18
1. Obiectivele lecției:
- Să înțeleagă cele patru principii fundamentale ale programării orientate pe obiecte (POO).
- Să înțeleagă conceptul de moștenire și aplicarea sa în POO.
- Să implementeze exemple practice care utilizează moștenirea pentru reutilizarea codului și extinderea funcționalității.
2. Principiile fundamentale ale POO
1. Încapsularea
- Definiție:
Gruparea datelor (atribute) și a funcțiilor (metode) care operează asupra acestor date într-o clasă. Încapsularea ascunde detaliile implementării folosind modificatori de acces precum private, protected și public. - 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 complexe și de a expune doar funcționalitățile relevante utilizatorului. Se realizează prin clase abstracte și interfețe. - 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;
}
};
3. Moștenirea
- Definiție:
Moștenirea permite unei clase noi (clasă derivată) să preia atributele și metodele unei clase existente (clasă de bază), reducând astfel redundanța și încurajând reutilizarea codului. - Tipuri de moștenire:
- Public: Membrii publici și protejați ai clasei de bază devin publici și protejați în clasa derivată.
- Protected: Membrii publici și protejați ai clasei de bază devin protejați în clasa derivată.
- Private: Toți membrii devin private în clasa derivată.
- Sintaxă:
class ClasaDerivata : ModAcces ClasaDeBaza {
// Membri suplimentari
};
- Exemplu:
class Animal {
public:
void mananca() {
cout << „Animalul mănâncă.” << endl;
}
};
class Pisica : public Animal {
public:
void miauna() {
cout << „Pisica miaună.” << endl;
}
};
int main() {
Pisica p;
p.mananca();
p.miauna();
return 0;
}
4. Polimorfism
- Definiție:
Capacitatea de a utiliza aceeași interfață pentru diferite tipuri de obiecte, permițând clasele derivate să implementeze comportamente specifice. - Exemplu:
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. Moștenirea în detaliu
1. Avantajele moștenirii
Avantaj | Descriere |
Reutilizarea codului | Permite utilizarea funcționalităților clasei de bază fără rescriere. |
Extensibilitate | Ușurează extinderea funcționalităților prin clase derivate. |
Claritate | Creează o ierarhie logică a claselor. |
2. Modificatori de acces și moștenirea
Modificator | Accesibil în clasa de bază | Accesibil în clasa derivată | Accesibil în afara clasei |
public | Da | Da | Da |
protected | Da | Da | Nu |
private | Da | Nu | Nu |
3. Exemple practice
Exemplu 1: Crearea unei ierarhii de clase
- Clasa de bază și clasa derivată:
class Vehicul {
public:
void porneste() {
cout << „Vehiculul pornește.” << endl;
}
};
class Masina : public Vehicul {
public:
void accelereaza() {
cout << „Mașina accelerează.” << endl;
}
};
int main() {
Masina m;
m.porneste();
m.accelereaza();
return 0;
}
Exemplu 2: Utilizarea constructorilor în moștenire
- Transmiterea datelor către clasa de bază:
class Persoana {
protected:
string nume;
public:
Persoana(string n) : nume(n) {}
};
class Student : public Persoana {
private:
int anStudiu;
public:
Student(string n, int an) : Persoana(n), anStudiu(an) {}
void afiseazaDetalii() {
cout << „Nume: ” << nume << „, An de studiu: ” << anStudiu << endl;
}
};
int main() {
Student s(„Andrei”, 2);
s.afiseazaDetalii();
return 0;
}
Exemplu 3: Polimorfism cu metode suprascrise
- Definirea metodelor virtuale:
class Forma {
public:
virtual void desen() {
cout << „Desenez o formă generică.” << endl;
}
};
class Dreptunghi : public Forma {
public:
void desen() override {
cout << „Desenez un dreptunghi.” << endl;
}
};
int main() {
Forma* f = new Dreptunghi();
f->desen(); // Apelează metoda din Dreptunghi
return 0;
}
4. Activități practice pentru elevi
- Creați o clasă de bază Animal cu metode pentru mananca() și doarme(). Extindeți clasele Pisica și Caine care adaugă metode specifice.
- Implementați o clasă abstractă Vehicul și derivatele Bicicleta și Motocicleta, fiecare cu o metodă descriere().
- Realizați un program care modelează o ierarhie pentru produse alimentare (Produs -> Fruct -> Mar).
5. Scheme logice
- Moștenirea simplă:
- Start -> Definire clasă de bază -> Definire clasă derivată -> Utilizare metode -> Stop.
- Constructori și moștenire:
- Start -> Constructor clasa derivată -> Apel constructor clasa de bază -> Inițializare -> Stop.
6. Concluzie
- Moștenirea este un principiu fundamental al POO care permite reutilizarea codului și extensibilitatea aplicațiilor.
- Este importantă utilizarea corectă a modificatorilor de acces pentru a proteja datele și pentru a controla vizibilitatea acestora.
- Moștenirea devine mai puternică atunci când este combinată cu polimorfismul, permițând implementări flexibile și scalabile.