PHP Academy · Lektion

Statische Eigenschaften und Methoden

Verwenden Sie statische Member und verstehen Sie, wann Sie sie ohne Instanz aufrufen können.

Statische Eigenschaften und Methoden ist eine kostenlose PHP Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des PHP Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der PHP Academy-Kurs umfasst insgesamt 4 Lektionen.

Einführung: Statische Eigenschaften und Methoden

Statische Member gehören zur Klasse selbst und nicht zu einer bestimmten Instanz. Greifen Sie mit ClassName::member oder innerhalb der Klasse mit self:: darauf zu. Sie werden von allen Instanzen gemeinsam genutzt.

Grundkonzepte

Wichtige Konzepte statischer Eigenschaften und Methoden:

Mit dem Schlüsselwort static deklarieren
Mit :: zugreifen (Scope-Resolution-Operator)
self:: innerhalb der Klasse; ClassName:: außerhalb der Klasse
Late Static Binding mit static::

Statische Eigenschaft

Beispiel:

<?php
class AppConfig {
    private static array $settings = [];

    public static function set(string $key, mixed $val): void {
        self::$settings[$key] = $val;
    }

    public static function get(string $key, mixed $default = null): mixed {
        return self::$settings[$key] ?? $default;
    }
}

AppConfig::set('debug', true);
echo AppConfig::get('debug') ? 'debug on' : 'debug off';

Statische Methode

Fortsetzung:

<?php
class MathHelper {
    public static function clamp(float $v, float $min, float $max): float {
        return max($min, min($max, $v));
    }

    public static function lerp(float $a, float $b, float $t): float {
        return $a + ($b - $a) * $t;
    }
}

echo MathHelper::clamp(150, 0, 100); // 100
echo MathHelper::lerp(0, 100, 0.5);  // 50

Singleton-Muster

Übung:

<?php
class Database {
    private static ?Database $instance = null;

    private function __construct() {
        echo 'Connected to DB';
    }

    public static function getInstance(): self {
        if (self::$instance === null) {
            self::$instance = new self();
        }
        return self::$instance;
    }
}

$db1 = Database::getInstance();  // 'Connected to DB'
$db2 = Database::getInstance();  // no output — same instance
echo ($db1 === $db2) ? 'same' : 'different'; // same

Statischer Zähler

Vertiefung:

<?php
class EventEmitter {
    private static int $instanceCount = 0;

    public function __construct() {
        self::$instanceCount++;
    }

    public static function count(): int {
        return self::$instanceCount;
    }
}

new EventEmitter();
new EventEmitter();
new EventEmitter();
echo EventEmitter::count();  // 3

Late Static Binding

Fortgeschrittene Verwendung:

<?php
class ParentClass {
    public static function create(): static {
        return new static();  // resolves to calling subclass
    }

    public function getClass(): string {
        return static::class;  // late static binding
    }
}

class ChildClass extends ParentClass {}

$obj = ChildClass::create();
echo $obj->getClass();  // ChildClass

Statische Factory

Praxisnahes Muster:

<?php
class Response {
    private function __construct(
        private int   $status,
        private mixed $body
    ) {}

    public static function ok(mixed $data): self {
        return new self(200, $data);
    }

    public static function notFound(): self {
        return new self(404, ['error' => 'Not Found']);
    }

    public function toJson(): string {
        return json_encode(['status' => $this->status, 'body' => $this->body]);
    }
}

echo Response::ok(['users' => []])->toJson();

Abwägungen zwischen statisch und instanzbezogen

Bewährte Vorgehensweisen:

<?php
// Static: no object needed, but harder to test/mock
class Validator {
    public static function isEmail(string $s): bool {
        return (bool) filter_var($s, FILTER_VALIDATE_EMAIL);
    }
}

// Instance: injectable dependency, testable
class ValidatorService {
    public function isEmail(string $s): bool {
        return (bool) filter_var($s, FILTER_VALIDATE_EMAIL);
    }
}
// Prefer instance classes in larger applications

Praxisnahes Muster

Hier wird alles anhand eines praxisnahen Musters für statische Eigenschaften und Methoden zusammengeführt.

Häufige Fehler

Vermeiden Sie diese häufigen Fehler bei statischen Eigenschaften und Methoden:

Statische Member werden von allen Instanzen gemeinsam genutzt
Bevorzugen Sie in vererbbaren Klassen Late Static Binding (static::) gegenüber self::
Singletons sind ein verbreitetes, aber manchmal übermäßig eingesetztes Muster
Statische Methoden lassen sich in Unit-Tests schwerer mocken

Schnelltest

Mit welchem Schlüsselwort greifen Sie innerhalb der Klasse unter Berücksichtigung der Vererbung auf eine statische Eigenschaft zu (Late Static Binding)?

Zusammenfassung: Statische Eigenschaften und Methoden

Sie haben statische Eigenschaften und Methoden behandelt. Diese wichtigen Punkte sollten Sie sich merken:

Statische Member werden von allen Instanzen gemeinsam genutzt
Bevorzugen Sie in vererbbaren Klassen Late Static Binding (static::) gegenüber self::
Singletons sind ein verbreitetes, aber manchmal übermäßig eingesetztes Muster
Statische Methoden lassen sich in Unit-Tests schwerer mocken

Häufig gestellte Fragen

Ist die Lektion „Statische Eigenschaften und Methoden“ kostenlos?

Ja — der vollständige Text von „Statische Eigenschaften und Methoden“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des PHP Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der PHP Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Statische Eigenschaften und Methoden“?

Verwenden Sie statische Member und verstehen Sie, wann Sie sie ohne Instanz aufrufen können. Du übst PHP Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um PHP Academy zu starten?

Keine Vorkenntnisse erforderlich. PHP Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.

Wie lange dauert die Lektion „Statische Eigenschaften und Methoden“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser PHP Academy-Lektion Code schreiben und ausführen?

Ja. Jede PHP Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu PHP Academy