Vorbește despre principiile programării orientate pe…

Programarea orientată pe obiecte (POO) se bazează pe patru principii cheie:

Încapsulare: Combinarea datelor (proprietăților) și a metodelor (funcțiilor) care lucrează cu aceste date într-un singur obiect. Acest lucru ascunde detaliile de implementare și oferă acces controlat la date.

<?php
class BankAccount {
    private float $balance = 0; // Date ascunse

    public function deposit(float $amount): void { // Metode care oferă acces
        if ($amount > 0) {
            $this->balance += $amount;
        }
    }

    public function getBalance(): float {
        return $this->balance;
    }
}
?>

Abstracție: Evidențierea caracteristicilor esențiale ale unui obiect și ascunderea detaliilor nesemnificative. Reprezintă un model simplificat al lumii reale.

<?php
abstract class Shape { // Clasă abstractă
    abstract public function area(): float; // Metodă abstractă

    // Poate avea și metode concrete, de exemplu:
    public function getDescription(): string {
        return "This is a shape.";
    }
}

class Circle extends Shape {
    private float $radius;

    public function __construct(float $radius) {
        $this->radius = $radius;
    }

    public function area(): float { // Implementarea metodei abstracte
        return M_PI * $this->radius * $this->radius;
    }
}
?>

Moștenire: Crearea unei clase noi (copil) pe baza uneia existente (părinte), moștenind proprietățile și metodele acesteia. Acest lucru promovează reutilizarea codului.

<?php
class Animal {
    protected string $name;

    public function __construct(string $name) {
        $this->name = $name;
    }

    public function eat(): void {
        echo "{$this->name} is eating.\n";
    }
}

class Dog extends Animal { // Dog moștenește de la Animal
    public function bark(): void {
        echo "{$this->name} says Woof!\n";
    }
}

$dog = new Dog("Buddy");
$dog->eat();  // Utilizarea metodei moștenite
$dog->bark();
?>

Polimorfism: Capacitatea obiectelor din clase diferite de a răspunde la aceeași apelare a metodei în mod diferit. "Multiple forme".

<?php
interface Speakable { // Interfață pentru exemplul de polimorfism
    public function speak(): void;
}

class Cat implements Speakable {
    public function speak(): void {
        echo "Meow!\n";
    }
}

class Duck implements Speakable {
    public function speak(): void {
        echo "Quack!\n";
    }
}

function makeSound(Speakable $animal): void { // Funcție acceptând diferite tipuri de obiecte
    $animal->speak(); // Apelarea aceleiași metode
}

$cat = new Cat();
$duck = new Duck();

makeSound($cat); // Apelarea metodei Cat::speak()
makeSound($duck); // Apelarea metodei Duck::speak()
?>

Vorbește despre principiile programării orientate pe obiect (POO).