Nette Documentation Preview

syntax
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 `$age` und einen Konstruktor, der diese Eigenschaft festlegt. Die Methode `howOldAreYou()` ermöglicht dann den Zugriff auf das Alter der Person.

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.

Schließlich kann die Definition von Eigenschaften mit ihrer Initialisierung über den Konstruktor wie folgt verkürzt und vereinfacht werden:

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


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 howOldAreYou()
	{
		return $this->age;
	}
}

class Student extends Person
{
	private $fieldOfStudy;

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

	function printInformation()
	{
		echo 'Age of student: ', $this->howOldAreYou();
		echo 'Field of study: ', $this->fieldOfStudy;
	}
}

$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.

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.


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.


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.


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.


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 OOP ermöglichen es uns, Fehler zu behandeln und zu verwalten, die während der Ausführung unseres Codes auftreten können. Sie sind im Wesentlichen Objekte, die dazu dienen, Fehler oder unerwartete Situationen in Ihrem Programm aufzuzeichnen.

In PHP gibt es für diese Objekte die eingebaute Klasse `Exception`. 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 Problem auftritt, können wir eine Ausnahme "werfen" (mit `throw`). Wenn wir diese Ausnahme "abfangen" und verarbeiten wollen, verwenden wir die Blöcke `try` und `catch`.

Schauen wir uns an, wie das funktioniert:

```php
try {
	throw new Exception('Message explaining the reason for the exception');

	// This code won't execute
	echo 'I am a message that nobody will read';

} catch (Exception $e) {
	echo 'Exception caught: '. $e->getMessage();
}
```

Es ist wichtig zu wissen, dass eine Ausnahme auch tiefer, während des Aufrufs anderer Methoden, ausgelöst werden kann.

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

Wir können auch eine Ausnahmehierarchie erstellen, bei der jede Ausnahmeklasse von der vorhergehenden erbt. Nehmen wir als Beispiel eine einfache Bankanwendung, die Einzahlungen und Abhebungen zulässt:

```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;
	}
}

$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.


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].

Einführung in die objektorientierte Programmierung

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:

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:

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 $age und einen Konstruktor, der diese Eigenschaft festlegt. Die Methode howOldAreYou() ermöglicht dann den Zugriff auf das Alter der Person.

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:

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.

Schließlich kann die Definition von Eigenschaften mit ihrer Initialisierung über den Konstruktor wie folgt verkürzt und vereinfacht werden:

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

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:

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:

$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:

use Transport\Car;

$car = new Car;

Vererbung

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:

class Person
{
	private $age;

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

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

class Student extends Person
{
	private $fieldOfStudy;

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

	function printInformation()
	{
		echo 'Age of student: ', $this->howOldAreYou();
		echo 'Field of study: ', $this->fieldOfStudy;
	}
}

$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.

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.

Komposition

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.

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

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:

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:

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

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.

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

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, 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:

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

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.

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

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.

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.

Abstrakte Klassen

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.

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.

Typ-Prüfung

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:

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.

Vergleich und Identität

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.
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

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:

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

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:

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

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.

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

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:

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 OOP ermöglichen es uns, Fehler zu behandeln und zu verwalten, die während der Ausführung unseres Codes auftreten können. Sie sind im Wesentlichen Objekte, die dazu dienen, Fehler oder unerwartete Situationen in Ihrem Programm aufzuzeichnen.

In PHP gibt es für diese Objekte die eingebaute Klasse Exception. 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 Problem auftritt, können wir eine Ausnahme „werfen“ (mit throw). Wenn wir diese Ausnahme „abfangen“ und verarbeiten wollen, verwenden wir die Blöcke try und catch.

Schauen wir uns an, wie das funktioniert:

try {
	throw new Exception('Message explaining the reason for the exception');

	// This code won't execute
	echo 'I am a message that nobody will read';

} catch (Exception $e) {
	echo 'Exception caught: '. $e->getMessage();
}

Es ist wichtig zu wissen, dass eine Ausnahme auch tiefer, während des Aufrufs anderer Methoden, ausgelöst werden kann.

Für einen try Block können mehrere catch Blöcke angegeben werden, wenn Sie verschiedene Arten von Ausnahmen erwarten.

Wir können auch eine Ausnahmehierarchie erstellen, bei der jede Ausnahmeklasse von der vorhergehenden erbt. Nehmen wir als Beispiel eine einfache Bankanwendung, die Einzahlungen und Abhebungen zulässt:

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;
	}
}

$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.

Bewährte Praktiken

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.