PHP OOP – Objektorientierte Programmierung

6 Kernkonzepte

Die wichtigsten OOP-Konzepte in PHP: class · extends · interface · trait · abstract · __magic Objektorientierte Programmierung ist das Herzstück moderner PHP-Anwendungen. Diese Konzepte sind essenziell für die Entwicklung wartbarer und skalierbarer Systeme.

Klassen – Eigenschaften & Methoden

class · public · private · protected · $this

// Klassendefinition class User { private $name; public function __construct($name) { $this->name = $name; } public function getName() { return $this->name; } }

Klassen sind Baupläne für Objekte. Sie definieren Eigenschaften (Variablen) und Methoden (Funktionen). Sichtbarkeitsmodifikatoren steuern den Zugriff: public, private, protected.

Sichtbarkeitsmodifikatoren

Modifikator	Beschreibung
public	Von überall zugänglich
private	Nur innerhalb der Klasse zugänglich
protected	Innerhalb der Klasse und abgeleiteten Klassen zugänglich

Beispiele

class Product {

private $price;

protected $name;

public $category;

public function __construct($name, $price) {

$this->name = $name;

$this->price = $price;

}

public function getPrice() {

return $this->price;

}

public function setPrice($price) {

$this->price = $price;

}

// Verwendung

$product = new Product("Laptop", 1200);

echo $product->getPrice(); // 1200

$product->category = "Elektronik"; // public Eigenschaft

Tipp: Verwenden Sie private für Eigenschaften und Methoden, die nicht von außen geändert werden sollen – so kapseln Sie die interne Logik.

Vererbung – extends & parent

extends · parent:: · override

// Basisklasse class Animal { public function speak() { return "Geräusch"; } } // Abgeleitete Klasse class Dog extends Animal { public function speak() { return parent::speak() . " + Bellen"; } }

Vererbung ermöglicht es, eine Klasse von einer anderen abzuleiten. Die Kindklasse erbt alle öffentlichen und geschützten Eigenschaften und Methoden. Mit parent:: kann auf die Elternklasse zugegriffen werden.

Beispiele

class Vehicle {

protected $brand;

public function __construct($brand) {

$this->brand = $brand;

}

public function info() {

return "Marke: " . $this->brand;

}

class Car extends Vehicle {

private $model;

public function __construct($brand, $model) {

parent::__construct($brand);

$this->model = $model;

}

public function info() {

return parent::info() . ", Modell: " . $this->model;

}

// Verwendung

$car = new Car("BMW", "X5");

echo $car->info(); // Marke: BMW, Modell: X5

Tipp: Verwenden Sie parent:: im Konstruktor, um die Initialisierung der Elternklasse sicherzustellen. Überschriebene Methoden können mit parent::method() erweitert werden.

Interfaces – Verträge definieren

interface · implements · const

// Interface definieren interface LoggerInterface { public function log($message): void; } // Klasse implementiert Interface class FileLogger implements LoggerInterface { public function log($message): void { // Logik } }

Interfaces definieren einen Vertrag, den Klassen erfüllen müssen. Sie enthalten Methodensignaturen ohne Implementierung. Eine Klasse kann mehrere Interfaces implementieren.

Beispiele

interface Payable {

public function calculatePrice(): float;

public function getDescription(): string;

}

interface Discountable {

public function applyDiscount($percent): void;

}

// Mehrere Interfaces implementieren

class Product implements Payable, Discountable {

private $price = 100;

private $name = "Produkt";

public function calculatePrice(): float {

return $this->price;

}

public function getDescription(): string {

return $this->name;

}

public function applyDiscount($percent): void {

$this->price -= $this->price * ($percent / 100);

}

Tipp: Interfaces ermöglichen Polymorphismus – Sie können Code schreiben, der mit jedem Objekt arbeitet, das ein bestimmtes Interface implementiert.

Traits – Code wiederverwenden

trait · use · insteadof · as

// Trait definieren trait LoggerTrait { public function log($message) { echo "Log: " . $message; } } // Trait verwenden class User { use LoggerTrait; }

Traits sind wiederverwendbare Codeblöcke, die Methoden und Eigenschaften in mehrere Klassen einbringen können. Sie lösen das Problem der Mehrfachvererbung in PHP.

Beispiele

trait TimestampTrait {

private $createdAt;

private $updatedAt;

public function setTimestamps() {

$this->createdAt = new DateTime();

$this->updatedAt = new DateTime();

}

public function getCreatedAt() {

return $this->createdAt;

}

trait JsonSerializableTrait {

public function toJson() {

return json_encode(get_object_vars($this));

}

// Mehrere Traits verwenden

class User {

use TimestampTrait, JsonSerializableTrait;

private $name;

public function __construct($name) {

$this->name = $name;

$this->setTimestamps();

}

// Konfliktlösung mit insteadof und as

trait A { function test() { echo "A"; } }

trait B { function test() { echo "B"; } }

class Test {

use A, B {

A::test insteadof B;

B::test as testB;

}

Tipp: Traits sind ideal für Querschnittsfunktionalitäten wie Logging, Timestamps, Serialisierung oder Validierung, die in vielen Klassen benötigt werden.

Abstracte Klassen – Vorlagen für Vererbung

abstract · abstract method · extends

// Abstracte Klasse abstract class Shape { abstract protected function getArea(): float; public function describe() { return "Fläche: " . $this->getArea(); } } // Konkrete Klasse class Circle extends Shape { private $radius; protected function getArea(): float { return pi() * $this->radius ** 2; } }

Abstracte Klassen können nicht instanziiert werden. Sie dienen als Vorlage für andere Klassen und können abstrakte Methoden enthalten, die in abgeleiteten Klassen implementiert werden müssen.

Beispiele

abstract class DatabaseConnection {

protected $host;

protected $username;

protected $password;

abstract public function connect(): void;

abstract public function query($sql): array;

public function __construct($host, $username, $password) {

$this->host = $host;

$this->username = $username;

$this->password = $password;

}

// Konkrete Implementierung für MySQL

class MySQLConnection extends DatabaseConnection {

private $pdo;

public function connect(): void {

$this->pdo = new PDO("mysql:host={$this->host}", $this->username, $this->password);

}

public function query($sql): array {

return $this->pdo->query($sql)->fetchAll();

}

Tipp: Abstrakte Klassen kombinieren die Vorteile von Interfaces (Verträge) und konkreten Klassen (Code-Wiederverwendung). Sie sind ideal für Basisklassen mit gemeinsamer Logik.

Magic Methods – Magische Methoden

__construct · __get · __set · __call · __toString

// Magic Methods class Magic { public function __construct() { // Konstruktor } public function __get($name) { // Undefinierte Eigenschaft } public function __set($name, $value) { // Undefinierte Eigenschaft setzen } public function __toString() { // String-Konvertierung } }

Magic Methods sind spezielle Methoden, die automatisch aufgerufen werden, wenn bestimmte Operationen mit einem Objekt durchgeführt werden. Sie beginnen mit einem doppelten Unterstrich (__).

Beispiele

class User {

private $data = [];

// Konstruktor

public function __construct($name) {

$this->data["name"] = $name;

}

// Dynamischer Getter

public function __get($name) {

return $this->data[$name] ?? null;

}

// Dynamischer Setter

public function __set($name, $value) {

$this->data[$name] = $value;

}

// Dynamischer Methodenaufruf

public function __call($method, $arguments) {

return call_user_func_array([$this, $method], $arguments);

}

// String-Konvertierung

public function __toString() {

return $this->data["name"] ?? "Unbekannt";

}

// Verwendung

$user = new User("Anna");

echo $user->name; // __get wird aufgerufen

$user->age = 30; // __set wird aufgerufen

echo $user; // __toString wird aufgerufen

Tipp: Magic Methods sollten sparsam verwendet werden, da sie die Lesbarkeit und Performance beeinträchtigen können. Für einfache Getter/Setter gibt es oft bessere Alternativen.

PHP OOP im Überblick

class Bauplan für Objekte
Eigenschaften & Methoden

extends Vererbung
parent::

interface Verträge
implements

trait Code-Wiederverwendung
use, insteadof

abstract Vorlagen
abstract class

__magic Magische Methoden
__construct, __get

Quick Summary

class

Klasse

extends

Vererbung

interface

Interface

trait

Traits

abstract

Abstract

__call

Magic Methods

class User { public $name; public function getName() { return $this->name; } }