Einführung in die objektorientierte Programmierung
**************************************************

.[perex]
Der Begriff "OOP" steht für Object-Oriented Programming (objektorientierte Programmierung), eine Methode zur Organisation und Strukturierung von Code. OOP ermöglicht es uns, ein Programm als eine Sammlung von Objekten zu betrachten, die miteinander kommunizieren, und nicht als eine Abfolge von Befehlen und Funktionen.

In OOP ist ein "Objekt" eine Einheit, die Daten und Funktionen enthält, die mit diesen Daten arbeiten. Objekte werden auf der Grundlage von "Klassen" erstellt, die als Entwürfe oder Vorlagen für Objekte verstanden werden können. Sobald wir eine Klasse haben, können wir ihre "Instanz" erstellen, d. h. ein spezifisches Objekt, das aus dieser Klasse besteht.

Schauen wir uns an, wie wir eine einfache Klasse in PHP erstellen können. Bei der Definition einer Klasse verwenden wir das Schlüsselwort "class", gefolgt vom Klassennamen und geschweiften Klammern, die die Funktionen der Klasse (genannt "Methoden") und die Variablen der Klasse (genannt "Eigenschaften" oder "Attribute") einschließen:

```php
class Car
{
	function honk()
	{
		echo 'Beep beep!';
	}
}
```

In diesem Beispiel haben wir eine Klasse namens `Car` mit einer Funktion (oder "Methode") namens `honk` erstellt.

Jede Klasse sollte nur eine Hauptaufgabe lösen. Wenn eine Klasse zu viele Aufgaben hat, kann es sinnvoll sein, sie in kleinere, spezialisierte Klassen aufzuteilen.

Klassen werden in der Regel in separaten Dateien gespeichert, damit der Code übersichtlich bleibt und leicht zu navigieren ist. Der Dateiname sollte mit dem Klassennamen übereinstimmen, für die Klasse `Car` wäre der Dateiname also `Car.php`.

Bei der Benennung von Klassen sollte man sich an die "PascalCase"-Konvention halten, d. h. jedes Wort im Namen beginnt mit einem Großbuchstaben, und es gibt keine Unterstriche oder andere Trennzeichen. Methoden und Eigenschaften folgen der "camelCase"-Konvention, das heißt, sie beginnen mit einem Kleinbuchstaben.

Einige Methoden in PHP haben besondere Funktionen und werden mit `__` (zwei Unterstrichen) eingeleitet. Eine der wichtigsten Spezialmethoden ist der "Konstruktor", der mit `__construct` gekennzeichnet ist. Der Konstruktor ist eine Methode, die automatisch aufgerufen wird, wenn eine neue Instanz einer Klasse erstellt wird.

Wir verwenden den Konstruktor häufig, um den Anfangszustand eines Objekts festzulegen. Wenn Sie beispielsweise ein Objekt erstellen, das eine Person darstellt, können Sie den Konstruktor verwenden, um deren Alter, Namen oder andere Attribute festzulegen.

Schauen wir uns an, wie man einen Konstruktor in PHP verwendet:

```php
class Person
{
	private $age;

	function __construct($age)
	{
		$this->age = $age;
	}

	function howOldAreYou()
	{
		return $this->age;
	}
}

$person = new Person(25);
echo $person->howOldAreYou(); // Outputs: 25
```

In diesem Beispiel hat die Klasse `Person` eine Eigenschaft (Variable) `$age` und einen Konstruktor, der diese Eigenschaft setzt. Die Methode `howOldAreYou()` ermöglicht dann den Zugriff auf das Alter der Person.

Die Pseudovariable `$this` wird innerhalb der Klasse für den Zugriff auf die Eigenschaften und Methoden des Objekts verwendet.

Das Schlüsselwort `new` wird verwendet, um eine neue Instanz einer Klasse zu erstellen. Im obigen Beispiel haben wir eine neue Person im Alter von 25 Jahren erstellt.

Sie können auch Standardwerte für Konstruktorparameter festlegen, wenn diese bei der Erstellung eines Objekts nicht angegeben werden. Zum Beispiel:

```php
class Person
{
	private $age;

	function __construct($age = 20)
	{
		$this->age = $age;
	}

	function howOldAreYou()
	{
		return $this->age;
	}
}

$person = new Person;  // if no argument is passed, parentheses can be omitted
echo $person->howOldAreYou(); // Outputs: 20
```

Wenn Sie in diesem Beispiel bei der Erstellung eines `Person` Objekts kein Alter angeben, wird der Standardwert von 20 verwendet.

Das Schöne daran ist, dass die Eigenschaftsdefinition mit ihrer Initialisierung über den Konstruktor wie folgt verkürzt und vereinfacht werden kann:

```php
class Person
{
	function __construct(
		private $age = 20,
	) {
	}
}
```

Der Vollständigkeit halber sei erwähnt, dass Objekte neben Konstruktoren auch Destruktoren haben können (Methode `__destruct`), die aufgerufen werden, bevor das Objekt aus dem Speicher freigegeben wird.


Namespaces .[#toc-namespaces]
-----------------------------

Namensräume ermöglichen es uns, verwandte Klassen, Funktionen und Konstanten zu organisieren und zu gruppieren und gleichzeitig Benennungskonflikte zu vermeiden. Man kann sie sich wie Ordner auf einem Computer vorstellen, wobei jeder Ordner Dateien enthält, die sich auf ein bestimmtes Projekt oder Thema beziehen.

Namensräume sind besonders nützlich in größeren Projekten oder bei der Verwendung von Bibliotheken von Drittanbietern, wo es zu Konflikten bei der Benennung von Klassen kommen kann.

Stellen Sie sich vor, Sie haben in Ihrem Projekt eine Klasse mit dem Namen `Car`, die Sie in einen Namensraum mit dem Namen `Transport` einfügen möchten. Sie würden folgendermaßen vorgehen:

```php
namespace Transport;

class Car
{
	function honk()
	{
		echo 'Beep beep!';
	}
}
```

Wenn Sie die Klasse `Car` in einer anderen Datei verwenden wollen, müssen Sie angeben, aus welchem Namespace die Klasse stammt:

```php
$car = new Transport\Car;
```

Zur Vereinfachung können Sie am Anfang der Datei angeben, welche Klasse aus einem bestimmten Namespace Sie verwenden wollen, so dass Sie Instanzen erstellen können, ohne den vollständigen Pfad angeben zu müssen:

```php
use Transport\Car;

$car = new Car;
```


Vererbung .[#toc-inheritance]
-----------------------------

Die Vererbung ist ein Werkzeug der objektorientierten Programmierung, das es ermöglicht, neue Klassen auf der Grundlage bestehender Klassen zu erstellen, deren Eigenschaften und Methoden zu erben und sie bei Bedarf zu erweitern oder neu zu definieren. Die Vererbung gewährleistet die Wiederverwendbarkeit des Codes und die Klassenhierarchie.

Einfach ausgedrückt: Wenn wir eine Klasse haben und eine andere davon abgeleitete Klasse mit einigen Änderungen erstellen möchten, können wir die neue Klasse von der ursprünglichen Klasse "erben".

In PHP wird die Vererbung mit dem Schlüsselwort `extends` realisiert.

Unsere Klasse `Person` speichert Altersinformationen. Wir können eine weitere Klasse, `Student`, erstellen, die `Person` erweitert und Informationen über das Studienfach hinzufügt.

Schauen wir uns ein Beispiel an:

```php
class Person
{
	private $age;

	function __construct($age)
	{
		$this->age = $age;
	}

	function printInformation()
	{
		echo "Age: {$this->age} years\n";
	}
}

class Student extends Person
{
	private $fieldOfStudy;

	function __construct($age, $fieldOfStudy)
	{
		parent::__construct($age);
		$this->fieldOfStudy = $fieldOfStudy;
	}

	function printInformation()
	{
		parent::printInformation();
		echo "Field of study: {$this->fieldOfStudy} \n";
	}
}

$student = new Student(20, 'Computer Science');
$student->printInformation();
```

Wie funktioniert dieser Code?

- Wir haben das Schlüsselwort `extends` verwendet, um die Klasse `Person` zu erweitern, d.h. die Klasse `Student` erbt alle Methoden und Eigenschaften von `Person`.

- Mit dem Schlüsselwort `parent::` können wir Methoden der übergeordneten Klasse aufrufen. In diesem Fall haben wir den Konstruktor der Klasse `Person` aufgerufen, bevor wir der Klasse `Student` unsere eigenen Funktionen hinzugefügt haben. Ähnlich verhält es sich mit der Vorgängermethode `printInformation()`, bevor wir die Schülerinformationen auflisten.

Vererbung ist für Situationen gedacht, in denen es eine "ist ein"-Beziehung zwischen Klassen gibt. Zum Beispiel ist eine `Student` eine `Person`. Eine Katze ist ein Tier. Sie ermöglicht es uns, in Fällen, in denen wir ein Objekt (z. B. "Person") im Code erwarten, stattdessen ein abgeleitetes Objekt zu verwenden (z. B. "Student").

Es ist wichtig zu erkennen, dass der Hauptzweck der Vererbung **nicht** darin besteht, doppelten Code zu verhindern. Im Gegenteil, der Missbrauch von Vererbung kann zu komplexem und schwer zu wartendem Code führen. Wenn es keine "ist ein"-Beziehung zwischen Klassen gibt, sollten wir Komposition anstelle von Vererbung in Betracht ziehen.

Beachten Sie, dass die Methoden `printInformation()` in den Klassen `Person` und `Student` leicht unterschiedliche Informationen ausgeben. Und wir können weitere Klassen hinzufügen (z. B. `Employee`), die andere Implementierungen dieser Methode bereitstellen werden. Die Fähigkeit von Objekten verschiedener Klassen, auf dieselbe Methode auf unterschiedliche Weise zu reagieren, wird als Polymorphismus bezeichnet:

```php
$people = [
	new Person(30),
	new Student(20, 'Computer Science'),
	new Employee(45, 'Director'),
];

foreach ($people as $person) {
	$person->printInformation();
}
```


Komposition .[#toc-composition]
-------------------------------

Komposition ist eine Technik, bei der wir, anstatt Eigenschaften und Methoden einer anderen Klasse zu erben, einfach deren Instanz in unserer Klasse verwenden. Auf diese Weise können wir Funktionalitäten und Eigenschaften mehrerer Klassen kombinieren, ohne komplexe Vererbungsstrukturen zu schaffen.

Ein Beispiel: Wir haben eine Klasse `Engine` und eine Klasse `Car`. Anstatt zu sagen "Ein Auto ist ein Motor", sagen wir "Ein Auto hat einen Motor", was eine typische Kompositionsbeziehung ist.

```php
class Engine
{
	function start()
	{
		echo 'Engine is running.';
	}
}

class Car
{
	private $engine;

	function __construct()
	{
		$this->engine = new Engine;
	}

	function start()
	{
		$this->engine->start();
		echo 'The car is ready to drive!';
	}
}

$car = new Car;
$car->start();
```

In diesem Fall verfügt die Klasse `Car` nicht über alle Eigenschaften und Methoden der Klasse `Engine`, aber sie hat über die Eigenschaft `$engine` Zugang zu ihnen.

Der Vorteil der Komposition ist eine größere Flexibilität bei der Gestaltung und eine bessere Anpassungsfähigkeit an künftige Änderungen.


Sichtbarkeit .[#toc-visibility]
-------------------------------

In PHP können Sie "Sichtbarkeit" für Klasseneigenschaften, Methoden und Konstanten definieren. Die Sichtbarkeit bestimmt, wo Sie auf diese Elemente zugreifen können.

1. **Öffentlich:** Wenn ein Element als `public` gekennzeichnet ist, bedeutet dies, dass Sie von überall darauf zugreifen können, auch außerhalb der Klasse.

2. **Geschützt:** Ein als `protected` gekennzeichnetes Element ist nur innerhalb der Klasse und aller ihrer Nachkommen (Klassen, die von ihr erben) zugänglich.

3. **Privat:** Wenn ein Element als `private` gekennzeichnet ist, kann man nur innerhalb der Klasse, in der es definiert wurde, darauf zugreifen.

Wenn Sie die Sichtbarkeit nicht angeben, setzt PHP sie automatisch auf `public`.

Schauen wir uns einen Beispielcode an:

```php
class VisibilityExample
{
	public $publicProperty = 'Public';
	protected $protectedProperty = 'Protected';
	private $privateProperty = 'Private';

	public function printProperties()
	{
		echo $this->publicProperty;     // Works
		echo $this->protectedProperty;  // Works
		echo $this->privateProperty;    // Works
	}
}

$object = new VisibilityExample;
$object->printProperties();
echo $object->publicProperty;        // Works
// echo $object->protectedProperty;   // Throws an error
// echo $object->privateProperty;     // Throws an error
```

Fortsetzung der Klassenvererbung:

```php
class ChildClass extends VisibilityExample
{
	public function printProperties()
	{
		echo $this->publicProperty;     // Works
		echo $this->protectedProperty;  // Works
		// echo $this->privateProperty;   // Throws an error
	}
}
```

In diesem Fall kann die Methode `printProperties()` in der `ChildClass` auf die öffentlichen und geschützten Eigenschaften zugreifen, aber nicht auf die privaten Eigenschaften der übergeordneten Klasse.

Daten und Methoden sollten so versteckt wie möglich sein und nur über eine definierte Schnittstelle zugänglich sein. Auf diese Weise können Sie die interne Implementierung der Klasse ändern, ohne dass sich dies auf den restlichen Code auswirkt.


Final-Schlüsselwort .[#toc-final-keyword]
-----------------------------------------

In PHP können wir das Schlüsselwort `final` verwenden, wenn wir verhindern wollen, dass eine Klasse, Methode oder Konstante geerbt oder überschrieben wird. Wenn eine Klasse als `final` markiert ist, kann sie nicht erweitert werden. Wenn eine Methode als `final` markiert ist, kann sie in einer Unterklasse nicht überschrieben werden.

Wenn wir wissen, dass eine bestimmte Klasse oder Methode nicht mehr geändert wird, können wir leichter Änderungen vornehmen, ohne uns Gedanken über mögliche Konflikte zu machen. Wir können zum Beispiel eine neue Methode hinzufügen, ohne befürchten zu müssen, dass ein Nachkomme bereits eine Methode mit demselben Namen hat, was zu einer Kollision führen würde. Oder wir können die Parameter einer Methode ändern, ohne das Risiko einer Inkonsistenz mit einer überschriebenen Methode in einem Nachfahren einzugehen.

```php
final class FinalClass
{
}

// The following code will throw an error because we cannot inherit from a final class.
class ChildOfFinalClass extends FinalClass
{
}
```

In diesem Beispiel führt der Versuch, von der endgültigen Klasse `FinalClass` zu erben, zu einem Fehler.


Statische Eigenschaften und Methoden .[#toc-static-properties-and-methods]
--------------------------------------------------------------------------

Wenn wir in PHP von "statischen" Elementen einer Klasse sprechen, meinen wir Methoden und Eigenschaften, die zur Klasse selbst gehören, nicht zu einer bestimmten Instanz der Klasse. Das bedeutet, dass Sie keine Instanz der Klasse erstellen müssen, um auf sie zuzugreifen. Stattdessen können Sie sie direkt über den Klassennamen aufrufen oder auf sie zugreifen.

Da statische Elemente zur Klasse und nicht zu ihren Instanzen gehören, können Sie die Pseudovariable `$this` nicht in statischen Methoden verwenden.

Die Verwendung von statischen Eigenschaften führt zu [verschleiertem Code voller Fallstricke |dependency-injection:global-state], so dass Sie sie niemals verwenden sollten, und wir werden hier auch kein Beispiel zeigen. Andererseits sind statische Methoden nützlich. Hier ist ein Beispiel:

```php
class Calculator
{
	public static function add($a, $b)
	{
		return $a + $b;
	}

	public static function subtract($a, $b)
	{
		return $a - $b;
	}
}

// Using the static method without creating an instance of the class
echo Calculator::add(5, 3); // Output: 8
echo Calculator::subtract(5, 3); // Output: 2
```

In diesem Beispiel haben wir eine Klasse `Calculator` mit zwei statischen Methoden erstellt. Wir können diese Methoden direkt aufrufen, ohne eine Instanz der Klasse mit dem `::` Operator zu erstellen. Statische Methoden sind besonders nützlich für Operationen, die nicht vom Zustand einer bestimmten Klasseninstanz abhängen.


Klassenkonstanten .[#toc-class-constants]
-----------------------------------------

Innerhalb von Klassen haben wir die Möglichkeit, Konstanten zu definieren. Konstanten sind Werte, die sich während der Ausführung des Programms nicht ändern. Im Gegensatz zu Variablen bleibt der Wert einer Konstante gleich.

```php
class Car
{
	public const NumberOfWheels = 4;

	public function displayNumberOfWheels(): int
	{
		echo self::NumberOfWheels;
	}
}

echo Car::NumberOfWheels;  // Output: 4
```

In diesem Beispiel haben wir eine Klasse `Car` mit der Konstante `NumberOfWheels`. Beim Zugriff auf die Konstante innerhalb der Klasse können wir das Schlüsselwort `self` anstelle des Klassennamens verwenden.


Objektschnittstellen .[#toc-object-interfaces]
----------------------------------------------

Objektschnittstellen fungieren als "Verträge" für Klassen. Wenn eine Klasse eine Objektschnittstelle implementieren soll, muss sie alle Methoden enthalten, die die Schnittstelle definiert. Auf diese Weise kann man sicherstellen, dass sich bestimmte Klassen an denselben "Vertrag" oder dieselbe Struktur halten.

In PHP werden Schnittstellen mit dem Schlüsselwort `interface` definiert. Alle Methoden, die in einer Schnittstelle definiert sind, sind öffentlich (`public`). Wenn eine Klasse eine Schnittstelle implementiert, verwendet sie das Schlüsselwort `implements`.

```php
interface Animal
{
	function makeSound();
}

class Cat implements Animal
{
	public function makeSound()
	{
		echo 'Meow';
	}
}

$cat = new Cat;
$cat->makeSound();
```

Wenn eine Klasse eine Schnittstelle implementiert, aber nicht alle erwarteten Methoden definiert sind, wird PHP einen Fehler ausgeben.

Eine Klasse kann mehrere Schnittstellen auf einmal implementieren, was sich von der Vererbung unterscheidet, bei der eine Klasse nur von einer Klasse erben kann:

```php
interface Guardian
{
	function guardHouse();
}

class Dog implements Animal, Guardian
{
	public function makeSound()
	{
		echo 'Bark';
	}

	public function guardHouse()
	{
		echo 'Dog diligently guards the house';
	}
}
```


Abstrakte Klassen .[#toc-abstract-classes]
------------------------------------------

Abstrakte Klassen dienen als Basisvorlagen für andere Klassen, aber Sie können ihre Instanzen nicht direkt erstellen. Sie enthalten eine Mischung aus vollständigen Methoden und abstrakten Methoden, die keinen definierten Inhalt haben. Klassen, die von abstrakten Klassen erben, müssen Definitionen für alle abstrakten Methoden der Elternklasse bereitstellen.

Wir verwenden das Schlüsselwort `abstract`, um eine abstrakte Klasse zu definieren.

```php
abstract class AbstractClass
{
	public function regularMethod()
	{
		echo 'This is a regular method';
	}

	abstract public function abstractMethod();
}

class Child extends AbstractClass
{
	public function abstractMethod()
	{
		echo 'This is the implementation of the abstract method';
	}
}

$instance = new Child;
$instance->regularMethod();
$instance->abstractMethod();
```

In diesem Beispiel haben wir eine abstrakte Klasse mit einer regulären und einer abstrakten Methode. Dann haben wir eine Klasse `Child`, die von `AbstractClass` erbt und eine Implementierung für die abstrakte Methode bereitstellt.

Was ist der Unterschied zwischen Schnittstellen und abstrakten Klassen? Abstrakte Klassen können sowohl abstrakte als auch konkrete Methoden enthalten, während Schnittstellen nur festlegen, welche Methoden die Klasse implementieren muss, aber keine Implementierung anbieten. Eine Klasse kann nur von einer abstrakten Klasse erben, kann aber eine beliebige Anzahl von Schnittstellen implementieren.


Typ-Prüfung .[#toc-type-checking]
---------------------------------

Beim Programmieren ist es wichtig, sicherzustellen, dass die Daten, mit denen wir arbeiten, vom richtigen Typ sind. In PHP gibt es Werkzeuge, die diese Sicherheit bieten. Die Überprüfung, ob die Daten vom richtigen Typ sind, nennt man "Typüberprüfung".

Typen, denen wir in PHP begegnen können:

1. **Basistypen**: Dazu gehören `int` (Ganzzahlen), `float` (Gleitkommazahlen), `bool` (boolesche Werte), `string` (Strings), `array` (Arrays) und `null`.
2. **Klassen**: Wenn ein Wert eine Instanz einer bestimmten Klasse sein soll.
3. **Schnittstellen**: Definiert eine Reihe von Methoden, die eine Klasse implementieren muss. Ein Wert, der eine Schnittstelle erfüllt, muss über diese Methoden verfügen.
4. **Mischtypen**: Wir können festlegen, dass eine Variable mehrere zulässige Typen haben kann.
5. **Void**: Dieser spezielle Typ gibt an, dass eine Funktion oder Methode keinen Wert zurückgibt.

Schauen wir uns an, wie wir den Code ändern können, um Typen einzubeziehen:

```php
class Person
{
	private int $age;

	public function __construct(int $age)
	{
		$this->age = $age;
	}

	public function printAge(): void
	{
		echo "This person is {$this->age} years old.";
	}
}

/**
 * A function that accepts a Person object and prints the person's age.
 */
function printPersonAge(Person $person): void
{
	$person->printAge();
}
```

Auf diese Weise stellen wir sicher, dass unser Code Daten des richtigen Typs erwartet und mit ihnen arbeitet, was uns hilft, mögliche Fehler zu vermeiden.

Einige Typen können nicht direkt in PHP geschrieben werden. In diesem Fall werden sie im phpDoc-Kommentar aufgeführt, dem Standardformat für die Dokumentation von PHP-Code, das mit `/**` beginnt und mit `*/` endet. Es ermöglicht Ihnen, Beschreibungen von Klassen, Methoden usw. hinzuzufügen. Außerdem können Sie komplexe Typen mit den so genannten Annotationen `@var`, `@param` und `@return` auflisten. Diese Typen werden dann von statischen Code-Analyse-Tools verwendet, aber nicht von PHP selbst überprüft.

```php
class Registry
{
	/** @var array<Person>  indicates that it's an array of Person objects */
	private array $persons = [];

	public function addPerson(Person $person): void
	{
		$this->persons[] = $person;
	}
}
```


Vergleich und Identität .[#toc-comparison-and-identity]
-------------------------------------------------------

In PHP können Sie Objekte auf zwei Arten vergleichen:

1. Wertevergleich `==`: Es wird geprüft, ob die Objekte der gleichen Klasse angehören und die gleichen Werte in ihren Eigenschaften haben.
2. Identität `===`: Prüft, ob es sich um die gleiche Instanz des Objekts handelt.

```php
class Car
{
	public string $brand;

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

$car1 = new Car('Skoda');
$car2 = new Car('Skoda');
$car3 = $car1;

var_dump($car1 == $car2);   // true, because they have the same value
var_dump($car1 === $car2);  // false, because they are not the same instance
var_dump($car1 === $car3);  // true, because $car3 is the same instance as $car1
```


Der `instanceof` Operator .[#toc-the-instanceof-operator]
---------------------------------------------------------

Mit dem Operator `instanceof` können Sie feststellen, ob ein bestimmtes Objekt eine Instanz einer bestimmten Klasse ist, ein Nachkomme dieser Klasse oder ob es eine bestimmte Schnittstelle implementiert.

Stellen Sie sich vor, wir haben eine Klasse `Person` und eine weitere Klasse `Student`, die ein Nachkomme von `Person` ist:

```php
class Person
{
	private int $age;

	public function __construct(int $age)
	{
		$this->age = $age;
	}
}

class Student extends Person
{
	private string $major;

	public function __construct(int $age, string $major)
	{
		parent::__construct($age);
		$this->major = $major;
	}
}

$student = new Student(20, 'Computer Science');

// Check if $student is an instance of the Student class
var_dump($student instanceof Student);  // Output: bool(true)

// Check if $student is an instance of the Person class (because Student is a descendant of Person)
var_dump($student instanceof Person);   // Output: bool(true)
```

Aus den Ausgaben ist ersichtlich, dass das Objekt `$student` als Instanz der Klassen `Student` und `Person` betrachtet wird.


Fließende Schnittstellen .[#toc-fluent-interfaces]
--------------------------------------------------

Eine "Fluent Interface" ist eine Technik in der OOP, die es ermöglicht, Methoden in einem einzigen Aufruf zu verketten. Dies vereinfacht und verdeutlicht oft den Code.

Das Schlüsselelement einer fließenden Schnittstelle ist, dass jede Methode in der Kette einen Verweis auf das aktuelle Objekt zurückgibt. Dies wird durch die Verwendung von `return $this;` am Ende der Methode erreicht. Dieser Programmierstil wird häufig mit Methoden in Verbindung gebracht, die "Setter" genannt werden und die Werte der Eigenschaften eines Objekts festlegen.

Schauen wir uns an, wie eine fließende Schnittstelle für das Senden von E-Mails aussehen könnte:

```php
public function sendMessage()
{
	$email = new Email;
	$email->setFrom('sender@example.com')
		  ->setRecipient('admin@example.com')
		  ->setMessage('Hello, this is a message.')
		  ->send();
}
```

In diesem Beispiel werden die Methoden `setFrom()`, `setRecipient()` und `setMessage()` verwendet, um die entsprechenden Werte (Absender, Empfänger, Nachrichteninhalt) zu setzen. Nach dem Setzen jedes dieser Werte geben die Methoden das aktuelle Objekt (`$email`) zurück, so dass wir eine weitere Methode dahinter verketten können. Schließlich rufen wir die Methode `send()` auf, die die E-Mail tatsächlich versendet.

Dank der fließenden Schnittstellen können wir Code schreiben, der intuitiv und leicht lesbar ist.


Kopieren mit `clone` .[#toc-copying-with-clone]
-----------------------------------------------

In PHP können wir eine Kopie eines Objekts mit dem Operator `clone` erstellen. Auf diese Weise erhalten wir eine neue Instanz mit identischem Inhalt.

Wenn wir beim Kopieren eines Objekts einige seiner Eigenschaften ändern müssen, können wir eine spezielle Methode `__clone()` in der Klasse definieren. Diese Methode wird automatisch aufgerufen, wenn das Objekt geklont wird.

```php
class Sheep
{
	public string $name;

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

	public function __clone()
	{
		$this->name = 'Clone of ' . $this->name;
	}
}

$original = new Sheep('Dolly');
echo $original->name . "\n";  // Outputs: Dolly

$clone = clone $original;
echo $clone->name . "\n";     // Outputs: Clone of Dolly
```

In diesem Beispiel haben wir eine Klasse `Sheep` mit einer Eigenschaft `$name`. Wenn wir eine Instanz dieser Klasse klonen, sorgt die Methode `__clone()` dafür, dass der Name des geklonten Schafs das Präfix "Clone of" erhält.


Eigenschaften .[#toc-traits]
----------------------------

Traits in PHP sind ein Werkzeug, das die gemeinsame Nutzung von Methoden, Eigenschaften und Konstanten zwischen Klassen ermöglicht und die Duplizierung von Code verhindert. Man kann sie sich wie einen "Kopieren und Einfügen"-Mechanismus vorstellen (Strg-C und Strg-V), bei dem der Inhalt eines Traits in Klassen "eingefügt" wird. So können Sie Code wiederverwenden, ohne komplizierte Klassenhierarchien erstellen zu müssen.

Werfen wir einen Blick auf ein einfaches Beispiel für die Verwendung von Traits in PHP:

```php
trait Honking
{
	public function honk()
	{
		echo 'Beep beep!';
	}
}

class Car
{
	use Honking;
}

class Truck
{
	use Honking;
}

$car = new Car;
$car->honk(); // Outputs 'Beep beep!'

$truck = new Truck;
$truck->honk(); // Also outputs 'Beep beep!'
```

In diesem Beispiel haben wir einen Trait namens `Honking`, der eine Methode `honk()` enthält. Dann haben wir zwei Klassen: `Car` und `Truck`, die beide den Trait `Honking` verwenden. Infolgedessen "besitzen" beide Klassen die Methode `honk()`, und wir können sie für Objekte beider Klassen aufrufen.

Traits ermöglichen eine einfache und effiziente gemeinsame Nutzung von Code zwischen Klassen. Sie greifen nicht in die Vererbungshierarchie ein, d. h. `$car instanceof Honking` gibt `false` zurück.


Ausnahmen
---------

Ausnahmen in der OOP ermöglichen es uns, Fehler und unerwartete Situationen in unserem Code anständig zu behandeln. Sie sind Objekte, die Informationen über einen Fehler oder eine ungewöhnliche Situation enthalten.

In PHP haben wir eine eingebaute Klasse `Exception`, die als Basis für alle Ausnahmen dient. Sie verfügt über mehrere Methoden, mit denen wir weitere Informationen über die Ausnahme erhalten können, z. B. die Fehlermeldung, die Datei und die Zeile, in der der Fehler aufgetreten ist, usw.

Wenn ein Fehler im Code auftritt, können wir die Ausnahme mit dem Schlüsselwort `throw` "werfen".

```php
function division(float $a, float $b): float
{
	if ($b === 0) {
		throw new Exception('Division by zero!');
	}
	return $a / $b;
}
```

Wenn die Funktion `division()` null als zweites Argument erhält, löst sie eine Ausnahme mit der Fehlermeldung `'Division by zero!'` aus. Um zu verhindern, dass das Programm abstürzt, wenn die Ausnahme ausgelöst wird, fangen wir sie im Block `try/catch` ab:

```php
try {
	echo division(10, 0);
} catch (Exception $e) {
	echo 'Exception caught: '. $e->getMessage();
}
```

Code, der eine Ausnahme auslösen kann, wird in einen Block `try` eingeschlossen. Wenn die Ausnahme ausgelöst wird, geht die Codeausführung in einen Block `catch` über, in dem wir die Ausnahme behandeln können (z. B. eine Fehlermeldung schreiben).

Nach den Blöcken `try` und `catch` kann ein optionaler Block `finally` eingefügt werden, der immer ausgeführt wird, unabhängig davon, ob die Ausnahme ausgelöst wurde oder nicht (auch wenn `return`, `break` oder `continue` im Block `try` oder `catch` verwendet wird):

```php
try {
	echo division(10, 0);
} catch (Exception $e) {
	echo 'Exception caught: '. $e->getMessage();
} finally {
	// Code that is always executed whether the exception has been thrown or not
}
```

Wir können auch unsere eigenen Ausnahmeklassen (Hierarchie) erstellen, die von der Klasse Exception erben. Betrachten wir als Beispiel eine einfache Bankanwendung, die Einzahlungen und Abhebungen erlaubt:

```php
class BankingException extends Exception {}
class InsufficientFundsException extends BankingException {}
class ExceededLimitException extends BankingException {}

class BankAccount
{
	private int $balance = 0;
	private int $dailyLimit = 1000;

	public function deposit(int $amount): int
	{
		$this->balance += $amount;
		return $this->balance;
	}

	public function withdraw(int $amount): int
	{
		if ($amount > $this->balance) {
			throw new InsufficientFundsException('Not enough funds in the account.');
		}

		if ($amount > $this->dailyLimit) {
			throw new ExceededLimitException('Daily withdrawal limit exceeded.');
		}

		$this->balance -= $amount;
		return $this->balance;
	}
}
```

Mehrere `catch` Blöcke können für einen einzigen `try` Block angegeben werden, wenn Sie verschiedene Arten von Ausnahmen erwarten.

```php
$account = new BankAccount;
$account->deposit(500);

try {
	$account->withdraw(1500);
} catch (ExceededLimitException $e) {
	echo $e->getMessage();
} catch (InsufficientFundsException $e) {
	echo $e->getMessage();
} catch (BankingException $e) {
	echo 'An error occurred during the operation.';
}
```

In diesem Beispiel ist es wichtig, die Reihenfolge der `catch` Blöcke zu beachten. Da alle Ausnahmen von `BankingException` erben, würden alle Ausnahmen in diesem Block abgefangen werden, ohne dass der Code die nachfolgenden Blöcke von `catch` erreicht. Daher ist es wichtig, spezifischere Ausnahmen (d. h. solche, die von anderen erben) in der Reihenfolge der `catch` -Blöcke höher anzusiedeln als ihre übergeordneten Ausnahmen.


Wiederholungen .[#toc-iterations]
---------------------------------

In PHP können Sie mit der `foreach` Schleife durch Objekte laufen, ähnlich wie Sie durch ein Array laufen. Damit dies funktioniert, muss das Objekt eine spezielle Schnittstelle implementieren.

Die erste Möglichkeit besteht darin, die Schnittstelle `Iterator` zu implementieren, die über die Methoden `current()`, die den aktuellen Wert zurückgeben, `key()`, die den Schlüssel zurückgeben, `next()`, die zum nächsten Wert springen, `rewind()`, die zum Anfang springen, und `valid()`, die überprüft, ob wir schon am Ende sind, verfügt.

Die andere Möglichkeit besteht darin, eine Schnittstelle `IteratorAggregate` zu implementieren, die nur eine Methode `getIterator()` hat. Diese gibt entweder ein Platzhalterobjekt zurück, das die Durchquerung ermöglicht, oder sie kann ein Generator sein, eine spezielle Funktion, die `yield` verwendet, um Schlüssel und Werte nacheinander zurückzugeben:

```php
class Person
{
	public function __construct(
		public int $age,
	) {
	}
}

class Registry implements IteratorAggregate
{
	private array $people = [];

	public function addPerson(Person $person): void
	{
		$this->people[] = $person;
	}

	public function getIterator(): Generator
	{
		foreach ($this->people as $person) {
			yield $person;
		}
	}
}

$list = new Registry;
$list->addPerson(new Person(30));
$list->addPerson(new Person(25));

foreach ($list as $person) {
	echo "Age: {$person->age} years\n";
}
```


Bewährte Praktiken .[#toc-best-practices]
-----------------------------------------

Sobald Sie die Grundprinzipien der objektorientierten Programmierung beherrschen, ist es wichtig, sich auf die besten Praktiken der OOP zu konzentrieren. Diese helfen Ihnen, Code zu schreiben, der nicht nur funktional, sondern auch lesbar, verständlich und leicht zu warten ist.

1) **Trennung von Belangen**: Jede Klasse sollte eine klar definierte Verantwortung haben und sich nur mit einer Hauptaufgabe befassen. Wenn eine Klasse zu viele Aufgaben hat, kann es sinnvoll sein, sie in kleinere, spezialisierte Klassen aufzuteilen.
2) **Kapselung**: Daten und Methoden sollten so versteckt wie möglich sein und nur über eine definierte Schnittstelle zugänglich sein. Auf diese Weise können Sie die interne Implementierung einer Klasse ändern, ohne dass sich dies auf den restlichen Code auswirkt.
3) **Dependency Injection**: Anstatt Abhängigkeiten direkt innerhalb einer Klasse zu schaffen, sollten Sie sie von außen "injizieren". Für ein tieferes Verständnis dieses Prinzips empfehlen wir die [Kapitel über Dependency Injection |dependency-injection:introduction].