Erzählen Sie mir von den Prinzipien der…

Die objektorientierte Programmierung (OOP) basiert auf vier Schlüsselprinzipien:

Kapselung: Die Verbindung von Daten (Eigenschaften) und Methoden (Funktionen), die mit diesen Daten arbeiten, in einem einzigen Objekt. Dies verbirgt Implementierungsdetails und bietet kontrollierten Zugriff auf die Daten.

<?php
class BankAccount {
    private float $balance = 0; // Versteckte Daten

    public function deposit(float $amount): void { // Methoden, die Zugriff bieten
        if ($amount > 0) {
            $this->balance += $amount;
        }
    }

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

Abstraktion: Hervorhebung der wesentlichen Merkmale eines Objekts und Verbergen unwesentlicher Details. Es stellt ein vereinfachtes Modell der realen Welt dar.

<?php
abstract class Shape { // Abstrakte Klasse
    abstract public function area(): float; // Abstrakte Methode

    // Kann konkrete Methoden haben, z.B.: 
    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 { // Implementierung der abstrakten Methode
        return M_PI * $this->radius * $this->radius;
    }
}
?>

Vererbung: Erstellung einer neuen Klasse (Kind) basierend auf einer bestehenden (Eltern), die deren Eigenschaften und Methoden erbt. Dies fördert die Wiederverwendung von 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 erbt von Animal
    public function bark(): void {
        echo "{$this->name} says Woof!\n";
    }
}

$dog = new Dog("Buddy");
$dog->eat();  // Verwendung der geerbten Methode
$dog->bark();
?>

Polymorphismus: Die Fähigkeit von Objekten verschiedener Klassen, auf denselben Methodenaufruf unterschiedlich zu reagieren. "Viele Formen".

<?php
interface Speakable { // Schnittstelle für Beispiel-Polymorphismus
    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 { // Funktion akzeptiert verschiedene Objekttypen
    $animal->speak(); // Aufruf derselben Methode
}

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

makeSound($cat); // Aufruf der Methode Cat::speak()
makeSound($duck); // Aufruf der Methode Duck::speak()
?>

Erzählen Sie mir von den Prinzipien der objektorientierten Programmierung (OOP).