Parlez-moi des principes de la programmation orientée…

La POO repose sur quatre principes clés :

Encapsulation : La combinaison de données (propriétés) et de méthodes (fonctions) qui travaillent avec ces données en un seul objet. Cela masque les détails d'implémentation et fournit un accès contrôlé aux données.

<?php
class BankAccount {
    private float $balance = 0; // Données cachées

    public function deposit(float $amount): void { // Méthodes fournissant l'accès
        if ($amount > 0) {
            $this->balance += $amount;
        }
    }

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

Abstraction : Mettre en évidence les caractéristiques essentielles d'un objet et cacher les détails non essentiels. Représente un modèle simplifié du monde réel.

<?php
abstract class Shape { // Classe abstraite
    abstract public function area(): float; // Méthode abstraite

    // Peut avoir des méthodes concrètes, par exemple :
    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 { // Implémentation de la méthode abstraite
        return M_PI * $this->radius * $this->radius;
    }
}
?>

Héritage : Création d'une nouvelle classe (fille) basée sur une existante (parent), héritant de ses propriétés et méthodes. Cela favorise la réutilisation du code.

<?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 hérite de Animal
    public function bark(): void {
        echo "{$this->name} says Woof!\n";
    }
}

$dog = new Dog("Buddy");
$dog->eat();  // Utilisation de la méthode héritée
$dog->bark();
?>

Polymorphisme : La capacité d'objets de différentes classes à répondre à un même appel de méthode de manière différente. "Plusieurs formes".

<?php
interface Speakable { // Interface pour l'exemple de polymorphisme
    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 { // Fonction acceptant différents types d'objets
    $animal->speak(); // Appel de la même méthode
}

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

makeSound($cat); // Appel de la méthode Cat::speak()
makeSound($duck); // Appel de la méthode Duck::speak()
?>

Parlez-moi des principes de la programmation orientée objet (POO).