Definiția Programării Orientate pe Obiecte (OOP)
Programarea orientată pe obiecte (OOP) este un paradigm de programare care folosește „obiecte” – structuri de date care combină atât datele (atributele) cât și funcțiile (metodele) care operează asupra acestor date. OOP se concentrează pe crearea de clase care definesc obiectele și pe interacțiunile dintre aceste obiecte pentru a construi aplicații software.
Principiile de Bază ale OOP

1. Încapsularea (Encapsulation)
   • Încapsularea implică ascunderea detaliilor interne ale unui obiect și expunerea doar a unei interfețe publice. Aceasta protejează datele și oferă o barieră clară între comportamentul intern și utilizarea externă a obiectului.
   • Exemplu:

class Mașină: def __init__(self, marca, model): self.__marca = marca # atribute private self.__model = model def pornește(self): print("Mașina a pornit") def get_marca(self): return self.__marca

1. Moștenirea (Inheritance)
   • Moștenirea permite unei clase (subclasă) să moștenească atributele și metodele unei alte clase (superclasă). Aceasta promovează reutilizarea codului și extinderea funcționalității claselor existente.
   • Exemplu:

     class Vehicul: def __init__(self, viteza): self.viteza = viteza def conduce(self): print("Vehiculul se deplasează") class Mașină(Vehicul): def __init__(self, viteza, marca): super().__init__(viteza) self.marca = marca

2. Polimorfism (Polymorphism)
   • Polimorfismul permite obiectelor de clase diferite să fie tratate prin aceeași interfață, dar să răspundă diferit la aceleași metode. Acesta poate fi static (supraincărcarea funcțiilor) sau dinamic (suprascrierea funcțiilor).
   • Exemplu:

     class Animal: def sunet(self): pass class Câine(Animal): def sunet(self): print("Ham Ham") class Pisică(Animal): def sunet(self): print("Miau") def fă_sunet(animal): animal.sunet() câine = Câine() pisică = Pisică() fă_sunet(câine) # Output: Ham Ham fă_sunet(pisică) # Output: Miau

3. Abstractizare (Abstraction)
   • Abstractizarea implică simplificarea unui sistem complex prin expunerea doar a caracteristicilor esențiale și ascunderea detaliilor nerelevante. Aceasta se realizează prin intermediul claselor abstracte și a interfețelor.
   • Exemplu:

     from abc import ABC, abstractmethod class Vehicul(ABC): @abstractmethod def pornește(self): pass class Mașină(Vehicul): def pornește(self): print("Mașina a pornit")

Avantajele Utilizării OOP în Dezvoltarea Software-ului

• Modularitate: Codul este organizat în module (clase) care sunt ușor de gestionat și întreținut.
• Reutilizarea codului: Moștenirea permite reutilizarea claselor existente pentru a crea noi clase, economisind timp și efort.
• Scalabilitate și flexibilitate: Polimorfismul și abstractizarea permit extinderea și modificarea programelor fără a afecta alte părți ale codului.
• Îmbunătățirea colaborării: Codul este organizat în moduri mai naturale și intuitive, facilitând colaborarea între dezvoltatori.
• Securitate: Încapsularea protejează datele prin ascunderea detaliilor interne ale obiectelor.

Exemple de Limbaje de Programare care Suportă OOP

• Java
• C++
• Python
• C#
• Ruby
• PHP

Cum se Aplică OOP în Practică: Exemple Concrete

1. Gestionarea unui Sistem de Biblioteca

   class Carte: def __init__(self, titlu, autor): self.titlu = titlu self.autor = autor def descriere(self): return f"{self.titlu} scrisă de {self.autor}" class Biblioteca: def __init__(self): self.carti = [] def adaugă_carte(self, carte): self.carti.append(carte) def listă_cărți(self): for carte in self.carti: print(carte.descriere()) carte1 = Carte("1984", "George Orwell") carte2 = Carte("Brave New World", "Aldous Huxley") biblioteca = Biblioteca() biblioteca.adaugă_carte(carte1) biblioteca.adaugă_carte(carte2) biblioteca.listă_cărți()

2. Sistem de Gestionare a Angajaților

   class Angajat: def __init__(self, nume, salariu): self.nume = nume self.salariu = salariu def descriere(self): return f"Angajat: {self.nume}, Salariu: {self.salariu}" class Manager(Angajat): def __init__(self, nume, salariu, echipă): super().__init__(nume, salariu) self.echipă = echipă def descriere(self): descriere = super().descriere() return f"{descriere}, Manager al echipei: {', '.join([m.nume for m in self.echipă])}" angajat1 = Angajat("Alice", 50000) angajat2 = Angajat("Bob", 60000) manager = Manager("Carol", 80000, [angajat1, angajat2]) print(manager.descriere())

Aceste exemple ilustrează cum principiile OOP sunt utilizate pentru a structura și organiza codul, facilitând dezvoltarea, întreținerea și extinderea aplicațiilor software complexe.