PHP OOP: Der komplette Guide 2025

1. Klassen und Objekte

Eine Klasse ist ein Bauplan für Objekte. Ein Objekt ist eine Instanz einer Klasse. Klassen definieren Eigenschaften (Properties) und Methoden (Methods), die das Verhalten von Objekten bestimmen.

🏗️ Einfache Klasse definieren

<?php

class User
{
    // Eigenschaften (Properties)
    public string $name;
    public string $email;
    private int $age;

    // Methoden (Methods)
    public function getName(): string
    {
        return $this->name;
    }

    public function setAge(int $age): void
    {
        if ($age >= 0) {
            $this->age = $age;
        }
    }
}

🎯 Objekt erstellen und verwenden

// Objekt instanziieren
$user = new User();

// Eigenschaften setzen
$user->name = 'Max Mustermann';
$user->email = 'max@example.com';

// Methoden aufrufen
$user->setAge(30);
echo $user->getName(); // Max Mustermann

2. Eigenschaften und Methoden

Eigenschaften speichern den Zustand eines Objekts, während Methoden das Verhalten definieren. PHP unterstützt verschiedene Sichtbarkeitsmodifikatoren und Typisierung.

class Product
{
    // Typisierte Eigenschaften
    public string $name;
    private float $price;
    protected array $tags = [];
    
    // Konstanten
    public const TAX_RATE = 0.19;
}

class Calculator
{
    // Öffentliche Methode
    public function add(int $a, int $b): int
    {
        return $a + $b;
    }
    
    // Statische Methode
    public static function multiply(int $a, int $b): int
    {
        return $a * $b;
    }
}

🔧 Getter und Setter

class BankAccount
{
    private float $balance = 0.0;

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

    // Setter mit Validierung
    public function deposit(float $amount): void
    {
        if ($amount > 0) {
            $this->balance += $amount;
        } else {
            throw new InvalidArgumentException('Amount must be positive');
        }
    }
}

3. Konstruktor und Destruktor

Der Konstruktor wird beim Erstellen eines Objekts aufgerufen, der Destruktor beim Zerstören. PHP 8+ bietet Constructor Property Promotion für saubereren Code.

🚀 PHP 8+ Constructor Property Promotion

class User
{
    public function __construct(
        private string $name,
        private string $email,
        private DateTime $createdAt = new DateTime()
    ) {}

    public function getName(): string
    {
        return $this->name;
    }

    public function getEmail(): string
    {
        return $this->email;
    }
}

// Verwendung
$user = new User('Ada Lovelace', 'ada@example.com');

4. Vererbung (Inheritance)

Vererbung ermöglicht es, neue Klassen basierend auf bestehenden Klassen zu erstellen. Die Kindklasse erbt alle Eigenschaften und Methoden der Elternklasse und kann diese erweitern oder überschreiben.

👨‍👩‍👧‍👦 Basis- und abgeleitete Klassen

// Basisklasse
class Animal
{
    public function __construct(
        protected string $name,
        protected int $age
    ) {}

    public function makeSound(): string
    {
        return "Some generic animal sound";
    }

    public function getInfo(): string
    {
        return "{$this->name} is {$this->age} years old";
    }
}

// Abgeleitete Klasse
class Dog extends Animal
{
    public function __construct(
        string $name,
        int $age,
        private string $breed
    ) {
        parent::__construct($name, $age);
    }

    // Methode überschreiben
    public function makeSound(): string
    {
        return "Woof! Woof!";
    }

    public function fetch(): string
    {
        return "{$this->name} is fetching the ball!";
    }
}

5. Interfaces

Interfaces definieren Verträge, die Klassen implementieren müssen. Sie spezifizieren, welche Methoden eine Klasse haben muss, ohne die Implementierung vorzugeben.

📋 Interface definieren und implementieren

interface PaymentProcessorInterface
{
    public function processPayment(float $amount): bool;
    public function refund(string $transactionId): bool;
}

class StripePaymentProcessor implements PaymentProcessorInterface
{
    public function processPayment(float $amount): bool
    {
        // Stripe API Implementierung
        return $amount > 0;
    }

    public function refund(string $transactionId): bool
    {
        // Refund Implementierung
        return true;
    }
}

6. Traits

Traits ermöglichen es, Code zwischen Klassen zu teilen, ohne Vererbung zu verwenden. Sie lösen das Problem der Mehrfachvererbung in PHP.

🔄 Trait definieren und verwenden

trait Timestampable
{
    private DateTime $createdAt;
    private DateTime $updatedAt;

    public function touch(): void
    {
        $this->updatedAt = new DateTime();
    }

    public function getCreatedAt(): DateTime
    {
        return $this->createdAt;
    }
}

class User
{
    use Timestampable;

    public function __construct(
        private string $name
    ) {
        $this->createdAt = new DateTime();
        $this->updatedAt = new DateTime();
    }
}

7. Abstrakte Klassen

Abstrakte Klassen können nicht instanziiert werden und dienen als Basisklassen für andere Klassen. Sie können abstrakte Methoden definieren, die von Kindklassen implementiert werden müssen.

abstract class Shape
{
    protected string $color;

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

    // Abstrakte Methode - muss implementiert werden
    abstract public function calculateArea(): float;

    // Konkrete Methode
    public function getColor(): string
    {
        return $this->color;
    }
}

class Circle extends Shape
{
    public function __construct(
        string $color,
        private float $radius
    ) {
        parent::__construct($color);
    }

    public function calculateArea(): float
    {
        return pi() * $this->radius ** 2;
    }
}

8. Sichtbarkeit (Visibility)

PHP bietet drei Sichtbarkeitsmodifikatoren, die den Zugriff auf Eigenschaften und Methoden kontrollieren.

9. PHP 8+ Features

PHP 8+ bringt viele moderne OOP-Features, die die Entwicklung effizienter und typsicherer machen.

class DataProcessor
{
    public function process(
        string|array $data
    ): string {
        if (is_array($data)) {
            return json_encode($data);
        }
        return $data;
    }
}

enum Status: string
{
    case PENDING = 'pending';
    case APPROVED = 'approved';
    case REJECTED = 'rejected';
}

class Order
{
    public function __construct(
        private Status $status
    ) {}
}

🎨 Readonly Properties

class ImmutableUser
{
    public function __construct(
        public readonly string $id,
        public readonly string $email,
        public readonly DateTime $createdAt
    ) {}
}

// Eigenschaften können nach Initialisierung nicht geändert werden
$user = new ImmutableUser('123', 'user@example.com', new DateTime());
// $user->email = 'new@example.com'; // Fehler!

10. Best Practices