PHP Klassen und Objekte: Eigenschaften, Methoden, $this

Eine PHP-Klasse wird mit class Name { ... } deklariert und enthält Eigenschaften (Variablen) und Methoden (Funktionen). new Name() erzeugt daraus ein Objekt, und -> liest eine Eigenschaft oder ruft eine Methode auf: $user->name, $user->greet().

<?php
class User
{
    public string $name = 'Guest';

    public function greet(): string
    {
        return "Hello, {$this->name}";
    }
}

$user = new User();
echo $user->greet(), "\n";

$user->name = 'Ada';
echo $user->greet(), "\n";

Die Klasse ist der Bauplan, das Objekt ist ein Ding, das danach gebaut wurde. Du kannst aus einer Klasse so viele Objekte erzeugen, wie du brauchst, und jedes hat seine eigenen Eigenschaftswerte.

Eigenschaften und Methoden

Eine Eigenschaft wird mit einem Sichtbarkeits-Schlüsselwort, einem optionalen Typ und einem optionalen Standardwert deklariert. Eine Methode ist eine Funktion in der Klasse. In einer Methode ist $this das Objekt, auf dem die Methode aufgerufen wurde, also liest $this->balance den Kontostand dieses Objekts.

<?php
class Account
{
    public string $owner = '';
    public float $balance = 0;

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

    public function summary(): string
    {
        return sprintf('%s has %.2f', $this->owner, $this->balance);
    }
}

$a = new Account();
$a->owner = 'Ada';
$a->deposit(50);
$a->deposit(25.5);

$b = new Account();
$b->owner = 'Linus';
$b->deposit(10);

echo $a->summary(), "\n";
echo $b->summary(), "\n";

Jedes Objekt behält sein eigenes $balance: Eine Einzahlung auf $a berührt $b nicht. Eigenschaften nach new einzeln zu setzen wird mühsam; ein Konstruktor nimmt die Startwerte stattdessen als Argumente.

public, private und protected

Die Sichtbarkeit bestimmt, wer eine Eigenschaft anfassen oder eine Methode aufrufen darf:

Eine Eigenschaft private zu machen und Methoden anzubieten ist der Weg, wie eine Klasse ihre eigenen Regeln schützt. Hier kann sich der Kontostand nur über deposit() und withdraw() ändern, die ungültige Beträge ablehnen:

<?php
class Wallet
{
    private int $cents = 0;

    public function deposit(int $cents): void
    {
        if ($cents <= 0) {
            throw new InvalidArgumentException('Deposit must be positive');
        }
        $this->cents += $cents;
    }

    public function withdraw(int $cents): bool
    {
        if ($cents > $this->cents) {
            return false;
        }
        $this->cents -= $cents;
        return true;
    }

    public function balance(): int
    {
        return $this->cents;
    }
}

$w = new Wallet();
$w->deposit(500);
var_dump($w->withdraw(800));
var_dump($w->withdraw(200));
echo $w->balance(), "\n";

Die private Eigenschaft von außerhalb der Klasse zu lesen ist keine Warnung, sondern ein Error:

<?php
// This throws an Error on purpose: $cents is private
class Wallet
{
    private int $cents = 500;
}

$w = new Wallet();
echo $w->cents;

Typisierte Eigenschaften und nicht initialisierte Werte

Eine typisierte Eigenschaft ohne Standardwert ist zu Beginn nicht initialisiert, und das ist etwas anderes als null. Sie zu lesen, bevor etwas zugewiesen wurde, wirft einen Error. Gib ihr entweder einen Standardwert, weise ihr im Konstruktor etwas zu oder mach sie mit ?Type und = null nullable.

<?php
class Product
{
    public string $name;           // no default: uninitialized
    public ?string $sku = null;    // nullable with a default
    public int $stock = 0;
}

$p = new Product();
var_dump($p->sku, $p->stock);

try {
    echo $p->name;
} catch (Error $e) {
    echo $e->getMessage(), "\n";
}

$p->name = 'Keyboard';
echo $p->name, "\n";

Typen werden bei der Zuweisung durchgesetzt. Im Standardmodus (nicht strikt) wandelt $p->stock = '7' den numerischen String in 7 um, während $p->stock = 'many' einen TypeError wirft.

readonly-Eigenschaften

Eine readonly-Eigenschaft (PHP 8.1) lässt sich einmal beschreiben, aus der Klasse heraus, und danach nie wieder. Das ist der übliche Weg, Value Objects wie Geldbeträge oder IDs zu bauen. PHP 8.2 brachte readonly class, die jede Eigenschaft readonly macht.

<?php
class Order
{
    public readonly string $id;

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

$order = new Order('A-1001');
echo $order->id, "\n";

try {
    $order->id = 'B-2002';
} catch (Error $e) {
    echo $e->getMessage(), "\n";
}

Eine readonly-Eigenschaft muss einen Typ haben und darf keinen Standardwert haben. Wenn du eine geänderte Kopie brauchst, erzeugst du ein neues Objekt (new Order('B-2002')), statt das alte zu bearbeiten.

Ein Objekt mit __toString ausgeben

echo $object funktioniert nur, wenn die Klasse __toString() definiert. Die Methode liefert den String, den PHP verwenden soll, wann immer das Objekt als Text behandelt wird: bei echo, beim Verketten von Strings, in "{$object}".

<?php
class Money
{
    public function __construct(
        private int $cents,
        private string $currency = 'EUR',
    ) {}

    public function __toString(): string
    {
        return number_format($this->cents / 100, 2) . ' ' . $this->currency;
    }
}

$price = new Money(129900);
echo $price, "\n";
echo 'Total: ' . $price . "\n";
echo "Shipping: " . new Money(450, 'USD') . "\n";

// For debugging, print_r and var_dump show the properties
print_r(new Money(5));

Ohne __toString wirft echo $object einen Error („Object of class Money could not be converted to string“). Zum Debuggen funktionieren print_r() und var_dump() mit jedem Objekt und zeigen auch private Eigenschaften; siehe var_dump und print_r.

Eine Zuweisung kopiert ein Objekt nicht

Das ist der Fehler, der die meisten trifft, die von Arrays kommen. Ein Array zuzuweisen kopiert es. Ein Objekt zuzuweisen kopiert nur den Verweis: Beide Variablen zeigen dann auf dasselbe Objekt.

<?php
class Point
{
    public int $x = 0;
    public int $y = 0;
}

$a = new Point();
$b = $a;          // same object
$b->x = 10;
echo "a->x = {$a->x}\n";

$c = clone $a;    // independent copy
$c->x = 99;
echo "a->x = {$a->x}, c->x = {$c->x}\n";

var_dump($a === $b, $a === $c, $a == $c);
var_dump($a instanceof Point);
echo get_class($c), "\n";

clone macht eine flache Kopie: Enthält eine Eigenschaft ein weiteres Objekt, teilen sich beide Kopien weiterhin dieses innere Objekt. === ist nur bei demselben Objekt wahr, während == die Eigenschaftswerte zweier Objekte derselben Klasse vergleicht. Ein Objekt an eine Funktion zu übergeben funktioniert genauso wie eine Zuweisung, also kann eine Funktion das Objekt ändern, das sie bekommt.