Vertel me over de principes van objectgeoriënteerd…

OOP is gebaseerd op vier kernprincipes:

Encapsulatie: Het samenvoegen van gegevens (eigenschappen) en methoden (functies) die met deze gegevens werken, in één object. Dit verbergt implementatiedetails en biedt gecontroleerde toegang tot de gegevens.

<?php
class BankAccount {
    private float $balance = 0; // Verborgen gegevens

    public function deposit(float $amount): void { // Methodes die toegang bieden
        if ($amount > 0) {
            $this->balance += $amount;
        }
    }

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

Abstractie: Het benadrukken van de essentiële kenmerken van een object en het verbergen van niet-essentiële details. Het vertegenwoordigt een vereenvoudigd model van de echte wereld.

<?php
abstract class Shape { // Abstracte klasse
    abstract public function area(): float; // Abstracte methode

    // Kan concrete methoden hebben, bijvoorbeeld:
    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 { // Implementatie van de abstracte methode
        return M_PI * $this->radius * $this->radius;
    }
}
?>

Erfelijkheid: Het creëren van een nieuwe klasse (afgeleid) op basis van een bestaande (ouder), waarbij eigenschappen en methoden worden geërfd. Dit bevordert hergebruik van code.

<?php
class Animal {
    protected string $name;

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

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

class Dog extends Animal { // Dog erft van Animal
    public function bark(): void {
        echo "{$this->name} zegt Woof!\n";
    }
}

$dog = new Dog("Buddy");
$dog->eat();  // Gebruik van de geërfde methode
$dog->bark();
?>

Polymorfisme: De mogelijkheid van objecten van verschillende klassen om op dezelfde methodeaanroep op verschillende manieren te reageren. "Veelvorm".

<?php
interface Speakable { // Interface voor voorbeeld van polymorfisme
    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 { // Functie accepteert verschillende objecttypes
    $animal->speak(); // Aanroep van dezelfde methode
}

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

makeSound($cat); // Aanroep van Cat::speak()
makeSound($duck); // Aanroep van Duck::speak()
?>

Vertel me over de principes van objectgeoriënteerd programmeren (OOP).