Objektorientierte Programmierung in PHP verstehen

Objektorientierte Programmierung (OOP) ist eine Methode, Code rund um Objekte zu strukturieren — in sich geschlossene Einheiten, die Daten (sogenannte Eigenschaften) und das Verhalten, das auf diese Daten einwirkt (sogenannte Methoden), zusammenfassen. Anstatt eine lange Liste von Funktionen zu schreiben, die Daten hin und her reichen, modelliert man die Dinge aus dem Problembereich (einen Benutzer, eine Bestellung, eine Datenbankverbindung) als Objekte und lässt sie ihren eigenen Zustand verwalten.

PHP unterstützt OOP seit PHP 5, und moderne PHP-Frameworks wie Laravel und Symfony basieren fast vollständig darauf. Dieses Kapitel erklärt, was OOP ist, warum es existiert und wie die Kernideen auf die PHP-Syntax abgebildet werden. Am Ende werden Sie den Unterschied zwischen einer Klasse und einem Objekt kennen und die vier Säulen der OOP erkennen: Kapselung, Vererbung, Polymorphismus und Abstraktion.

Prozedurales vs. objektorientiertes PHP

Vor Klassen war PHP-Code typischerweise prozedural — eine Abfolge von Anweisungen und Funktionen, die auf einfachen Variablen arbeiteten:

$carMake = "Ford";
$carModel = "Mustang";

function describeCar($make, $model) {
  return "The car is a $make $model.";
}

echo describeCar($carMake, $carModel);
// The car is a Ford Mustang.

Das funktioniert, aber die Daten ($carMake, $carModel) und die Funktion, die sie verwendet, sind lose miteinander verbunden. Wenn ein Projekt wächst, wird es schwierig nachzuverfolgen, welche Funktionen zu welchen Daten gehören. OOP löst dieses Problem, indem es die Daten und das Verhalten in einer einzigen Klasse zusammenfasst.

Klassen und Objekte

Die beiden grundlegenden Konzepte in der OOP sind die Klasse und das Objekt:

• Eine Klasse ist ein Bauplan. Sie beschreibt, welche Eigenschaften und Methoden ein Objekt haben wird, ist aber kein Wert, den man direkt verwenden kann — wie ein Architekturplan für ein Haus.
• Ein Objekt ist eine konkrete Instanz, die aus diesem Bauplan erstellt wird, mit echten ausgefüllten Werten — wie ein tatsächlich nach dem Plan gebautes Haus.

In PHP deklariert man eine Klasse mit dem Schlüsselwort class und erstellt ein Objekt daraus mit dem Operator new:

class Car {
  public $make;
  public $model;
}

$car = new Car();   // $car is an object (an instance of Car)
$car->make = "Ford";
$car->model = "Mustang";

echo $car->make;    // Ford

Man kann so viele unabhängige Objekte aus einer Klasse erstellen, wie man benötigt, und jedes behält seine eigene Kopie der Eigenschaften. Der Pfeiloperator -> greift auf eine Eigenschaft oder Methode eines Objekts zu. Mehr dazu erfahren Sie unter PHP Klassen und Objekte.

Die vier Säulen der OOP

OOP basiert auf vier Kernprinzipien. PHP stellt für jedes davon ein eigenes Sprachfeature bereit.

Kapselung

Kapselung bedeutet, die Daten eines Objekts und die Methoden, die sie ändern, zusammenzuhalten und den Zugriff von außen zu kontrollieren. Indem man Eigenschaften als private markiert und sie nur über Methoden zugänglich macht, schützt man ein Objekt davor, in einen ungültigen Zustand zu geraten.

class BankAccount {
  private $balance = 0;

  public function deposit($amount) {
    if ($amount > 0) {
      $this->balance += $amount;
    }
  }

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

$account = new BankAccount();
$account->deposit(100);
echo $account->getBalance();   // 100

Hier kann $balance nicht direkt auf einen sinnlosen Wert gesetzt werden — jede Änderung läuft über deposit(), das die Eingabe validiert.

Vererbung

Vererbung ermöglicht es einer Klasse, die Eigenschaften und Methoden einer anderen wiederzuverwenden. Eine mit extends deklarierte Kindklasse erhält automatisch alles von ihrer Elternklasse und kann es ergänzen oder überschreiben. Dadurch wird die Duplizierung von gemeinsamem Code vermieden. Einzelheiten finden Sie unter PHP Vererbung.

class Vehicle {
  public function start() {
    return "Engine started.";
  }
}

class Car extends Vehicle {
  public function openTrunk() {
    return "Trunk opened.";
  }
}

$car = new Car();
echo $car->start();        // Engine started.  (inherited)
echo $car->openTrunk();    // Trunk opened.     (its own)

Polymorphismus

Polymorphismus („viele Formen") bedeutet, dass verschiedene Klassen auf denselben Methodenaufruf auf ihre eigene Weise reagieren können. Code, der makeSound() aufruft, muss nicht wissen, ob er einen Dog oder eine Cat hält:

class Dog {
  public function makeSound() { return "Woof"; }
}

class Cat {
  public function makeSound() { return "Meow"; }
}

foreach ([new Dog(), new Cat()] as $animal) {
  echo $animal->makeSound() . "\n";
}
// Woof
// Meow

Dies entfaltet seine volle Kraft in Kombination mit Interfaces, die garantieren, dass jede Klasse dieselbe Menge an Methoden bereitstellt.

Abstraktion

Abstraktion bedeutet, Implementierungsdetails hinter einer einfachen, klar definierten Schnittstelle zu verbergen. Benutzer einer Klasse arbeiten mit dem Was — nicht mit dem Wie. PHP unterstützt dies durch abstrakte Klassen und Interfaces, die Methodensignaturen ohne (oder mit teilweiser) Implementierung definieren.

Alles zusammen: ein vollständiges Beispiel

Die folgende Klasse kombiniert Eigenschaften, einen Konstruktor, der automatisch beim Erstellen des Objekts ausgeführt wird, und eine Methode:

class Car {
  public $color;
  public $make;
  public $model;

  function __construct($color, $make, $model) {
    $this->color = $color;
    $this->make  = $make;
    $this->model = $model;
  }

  function getDescription() {
    return "The car is a " . $this->make . " " . $this->model . " in " . $this->color . " color.";
  }
}

$car = new Car("red", "Ford", "Mustang");
echo $car->getDescription();
// The car is a Ford Mustang in red color.

Was hier passiert:

• Die Klasse Car deklariert drei öffentliche Eigenschaften — color, make und model.
• __construct() ist eine spezielle Methode, die PHP in dem Moment aufruft, in dem new Car(...) ausgeführt wird. Sie kopiert die Argumente mithilfe von $this in die Eigenschaften des Objekts, wobei $this stets auf das aktuelle Objekt verweist.
• getDescription() liest diese Eigenschaften und gibt einen Satz zurück.
• new Car("red", "Ford", "Mustang") erstellt das Objekt; der Aufruf von $car->getDescription() erzeugt die im Kommentar gezeigte Ausgabe.

Wann sollte man OOP verwenden?

OOP glänzt, wenn eine Anwendung viele verwandte Konzepte mit eigenen Daten und eigenem Verhalten hat, wenn man Code in einem Projekt wiederverwenden möchte oder wenn man mit einem Framework arbeitet, das OOP erwartet. Für ein kleines Einmalskript können einfache prozedurale Funktionen einfacher sein. Der Großteil von realem PHP — APIs, Web-Apps, Bibliotheken — setzt auf OOP, weil es wachsende Codebasen organisiert und testbar hält.

Fazit

Objektorientierte Programmierung organisiert Code rund um Objekte, die Daten mit Verhalten bündeln. Man definiert eine Klasse als Bauplan und erstellt Objekte daraus mit new. Die vier Säulen — Kapselung, Vererbung, Polymorphismus und Abstraktion — geben einem Werkzeuge, um Daten zu schützen, Code wiederzuverwenden und große Anwendungen wartbar zu halten.

Um tiefer einzutauchen, fahren Sie mit PHP Klassen und Objekte fort und erkunden Sie dann Vererbung, Interfaces, abstrakte Klassen und Traits.

Übungen