class

Das PHP-Schlüsselwort class

Das Schlüsselwort class definiert eine Klasse — einen Bauplan, der die Daten (Eigenschaften) und das Verhalten (Methoden) beschreibt, die eine Gruppe von Objekten teilt. Einzelne Objekte (auch Instanzen genannt) werden dann mit dem Operator new aus diesem Bauplan erstellt. Klassen sind die Grundlage der objektorientierten Programmierung (OOP) in PHP: Sie ermöglichen es, zusammengehörigen Zustand und Logik in einer einzigen, wiederverwendbaren Einheit zu bündeln, anstatt lose Variablen und Funktionen zu verstreuen.

Diese Seite erläutert, wie man eine Klasse deklariert, Eigenschaften und Methoden hinzufügt, Objekte mit einem Konstruktor initialisiert, den Zugriff mit Sichtbarkeitsmodifikatoren steuert, Daten mit Konstanten und statischen Membern teilt und Verhalten durch Vererbung wiederverwendet.

Syntax

Eine Klassendeklaration beginnt mit dem Schlüsselwort class, gefolgt von einem Namen und einem Rumpf in geschweiften Klammern:

<?php

class MyClass {
  // Properties and methods go here
}

Konventionsgemäß verwenden Klassennamen PascalCase (MyClass, BankAccount). Ein Klassenname darf kein reserviertes PHP-Wort sein, und der Rumpf — auch ein leerer — muss geschweifte Klammern verwenden. Das Definieren einer Klasse bewirkt für sich allein nichts; sie wird erst nützlich, wenn man ein Objekt daraus erstellt.

Eigenschaften und Methoden

Eine Eigenschaft ist eine Variable, die zu einem Objekt gehört. Eine Methode ist eine Funktion, die zu einer Klasse gehört. Innerhalb einer Methode verweist die spezielle Variable $this auf das aktuelle Objekt, sodass $this->name die Eigenschaft name dieses Objekts liest (oder schreibt):

<?php

class User {
  public string $name;          // a property

  public function greet(): string {   // a method
    return "Hi, I'm {$this->name}";
  }
}

$u = new User();
$u->name = "Ada";               // set the property on this object
echo $u->greet();               // Hi, I'm Ada

Beachte den Pfeil -> (nicht .) für den Zugriff auf Member und dass man $this->name schreibt, niemals $this->$name.

Der Konstruktor

Jede Eigenschaft einzeln zu setzen ist umständlich und fehleranfällig. Die Methode __construct() wird automatisch ausgeführt, wenn ein Objekt erstellt wird, und ermöglicht es, Anfangswerte in einem Schritt anzufordern und zuzuweisen. Die Argumente, die man an new übergibt, werden an den Konstruktor weitergeleitet:

<?php

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

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

  public function describe(): string
  {
    return "{$this->year} {$this->make} {$this->model}";
  }
}

$myCar = new Car("Ford", "Mustang", 2022);
echo $myCar->describe();   // 2022 Ford Mustang

Weitere Informationen, einschließlich der Konstruktor-Eigenschaftsförderung, findest du unter PHP-Konstruktor.

Sichtbarkeit

Jede Eigenschaft und jede Methode hat eine Sichtbarkeit, die steuert, von wo aus sie zugänglich ist:

• public — von überall zugänglich (Standard, wenn man es weglässt).
• protected — nur innerhalb der Klasse und ihrer Unterklassen zugänglich.
• private — nur innerhalb der Klasse zugänglich, die sie deklariert.

Das Verbergen des internen Zustands hinter private und das Bereitstellen über Methoden wird Kapselung genannt:

<?php

class BankAccount
{
  private float $balance = 0;     // cannot be touched directly from outside

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

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

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

Weitere Details findest du unter PHP-Zugriffsmodifikatoren.

Konstanten und statische Member

Verwende das Schlüsselwort const für Werte, die sich nie ändern, und das Schlüsselwort static für Daten und Methoden, die zur Klasse selbst gehören und nicht zu einem einzelnen Objekt. Auf beide wird mit dem Bereichsauflösungsoperator :: zugegriffen:

<?php

class Circle
{
  const PI = 3.14159;          // class constant
  public static int $count = 0; // shared across all instances

  public function __construct()
  {
    self::$count++;            // increment the shared counter
  }
}

new Circle();
new Circle();

echo Circle::PI;        // 3.14159
echo PHP_EOL;
echo Circle::$count;    // 2

Siehe PHP-Klassenkonstanten und PHP statische Methoden.

Vererbung

Eine Klasse kann mit extends eine andere erweitern, um deren Verhalten wiederzuverwenden und zu spezialisieren. Die Kindklasse erbt die Eigenschaften und Methoden der Elternklasse und kann sie überschreiben:

<?php

class Animal
{
  public function speak(): string
  {
    return "The animal makes a sound.";
  }
}

class Dog extends Animal
{
  public function speak(): string   // overrides the parent method
  {
    return "The dog barks.";
  }
}

echo (new Animal())->speak();   // The animal makes a sound.
echo PHP_EOL;
echo (new Dog())->speak();      // The dog barks.

Für eine tiefergehende Behandlung siehe PHP-Vererbung, und für Klassen, die einen Vertrag ohne Implementierung definieren, abstrakte Klassen und Interfaces.

Vollständiges Beispiel

Das folgende ausführbare Beispiel kombiniert einen Konstruktor mit Getter-Methoden und demonstriert Vererbung mit Methodenüberschreibung:

<?php

// Example 1
class Car
{
  public $make;
  public $model;
  public $year;

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

  public function getMake()
  {
    return $this->make;
  }

  public function getModel()
  {
    return $this->model;
  }

  public function getYear()
  {
    return $this->year;
  }
}

$myCar = new Car("Ford", "Mustang", 2022);
echo "Make: " . $myCar->getMake() . PHP_EOL;
echo "Model: " . $myCar->getModel() . PHP_EOL;
echo "Year: " . $myCar->getYear() . PHP_EOL;

// Output:
// Make: Ford
// Model: Mustang
// Year: 2022

// Example 2
class Animal
{
  public function speak()
  {
    echo "The animal speaks.";
  }
}

class Dog extends Animal
{
  public function speak()
  {
    echo "The dog barks.";
  }
}

$myAnimal = new Animal();
$myDog = new Dog();
$myAnimal->speak();
$myDog->speak();

// Output:
// The animal speaks.
// The dog barks.

Beispiel 1 erstellt Objekte mit einem Konstruktor und liest ihren Zustand über Getter; Beispiel 2 zeigt eine Dog-Unterklasse, die die von Animal geerbte Methode speak() überschreibt.

Zusammenfassung

• Das Schlüsselwort class definiert einen Bauplan; der Operator new erstellt Objekte daraus.
• Eigenschaften speichern die Daten eines Objekts, Methoden definieren sein Verhalten, und $this verweist auf das aktuelle Objekt innerhalb einer Methode.
• __construct() initialisiert ein Objekt bei seiner Erstellung.
• public, protected und private steuern, wo auf Member zugegriffen werden kann.
• const und static gehören zur Klasse selbst; auf sie wird mit :: zugegriffen.
• extends ermöglicht es einer Klasse, das Verhalten einer anderen zu erben und zu überschreiben.

Für einen umfassenderen Überblick darüber, wie diese Teile zusammenpassen, siehe PHP-Klassen und -Objekte.

Übungen