dozent.net
Projekt anfragen
Info

PHP OOP – Fortgeschrittene Technologien

In diesem Seminar vertiefst du die objektorientierte Programmierung (OOP) in PHP für die Entwicklung komplexer und skalierbarer Anwendungen. Im Fokus stehen saubere Software-Architekturen, gängige Entwurfsmuster (Design Patterns), Metaprogrammierung sowie moderne Sprachfeatures ab PHP 8.x — in drei Tagen. Ziel ist wartbarer, testbarer und stark typisierter Code nach aktuellen Industriestandards.

Für wen ist dieses Seminar

Erfahrene PHP-Entwickler, Backend-Software-Engineers und Architekten.

Das Angebot richtet sich an Unternehmen, Behörden und Selbstständige.

Was du mitbringen solltest

Gefestigtes Wissen in der PHP-Syntax und den Grundlagen der Objektorientierung (Klassen, Objekte, Vererbung, Sichtbarkeiten).

Geschult wird auf der jeweils aktuellen Version; bei Inhouse-Seminaren gern auch auf der Version, die ihr im Einsatz habt.

Detaillierte Inhalte

Architektur-Prinzipien und Code-Design

  • SOLID-Prinzipien in der PHP-Praxis umsetzen
  • Interfaces vs. Abstrakte Klassen: Gezielte Architekturentscheidungen
  • Dependency Injection (DI) und Inversion of Control (IoC)
  • Aufbau loser Kopplung für testbaren Code

Erweiterte Objektorientierung

  • Traits: Horizontale Code-Wiederverwendung, Precedence und Konfliktauflösung
  • Anonyme Klassen: Einsatzszenarien, Syntax und Memory Management
  • Magische Methoden im Detail (__invoke, __clone, __sleep, __wakeup, __callStatic)
  • Objekt-Klonen: Flache vs. tiefe Kopien (Deep Copy) implementieren
  • Strikte Typisierung: Union Types, Intersection Types, Return Type Hinting (static, mixed, never)

Strukturierung und Autoloading

  • Namespaces: Deklaration, Import (use), Aliasing und globale Räume
  • Autoloading-Konzepte: Eigene Autoloader via spl_autoload_register
  • PSR-4 Standard: Strukturierung von Klassen und Verzeichnissen
  • Weitere PSR-Standards für interoperablen Code: PSR-12 (Coding Style), PSR-3 (Logger Interface), PSR-11 (Container Interface)
  • Composer: Paketverwaltung, Abhängigkeiten und optimiertes Autoloading

Entwurfsmuster (Design Patterns) in PHP

  • Erzeugungsmuster: Factory Method, Abstract Factory, Singleton (inkl. Anti-Pattern-Diskussion)
  • Strukturmuster: Adapter, Decorator, Facade
  • Verhaltensmuster: Strategy, Observer, Command

Fehlerbehandlung und Ausnahmeverwaltung

  • Exception-Hierarchien: Eigene domänenspezifische Exception-Klassen entwerfen
  • Try-Catch-Finally Blöcke und Exception-Bubbling steuern
  • Globales Error- und Exception-Handling (set_exception_handler, set_error_handler)
  • Das Throwable Interface ab PHP 7/8

Qualitätssicherung: Tests und statische Analyse

  • Unit-Tests mit PHPUnit schreiben, ausführen und in bestehende Klassenhierarchien einbetten
  • Statische Analyse mit PHPStan/Psalm: Typfehler und Bugs vor der Laufzeit finden
  • Testbarkeit als Architektur-Kriterium: lose Kopplung und Dependency Injection erleichtern Mocking

Dynamische Programmierung und Meta-Daten

  • Closures und Anonyme Funktionen (Binding und das use-Schlüsselwort)
  • Arrow Functions (Pfeilfunktionen) für kompakten Code
  • Generatoren (yield) und das Iterator-Interface: speichereffiziente Verarbeitung großer Datenmengen
  • Reflection API: Klassen, Methoden und Eigenschaften zur Laufzeit analysieren und manipulieren
  • PHP Attribute (ehemals Annotations): Eigene Metadaten definieren und via Reflection auswerten

Moderne PHP-Features für OOP (PHP 8.x)

  • Constructor Property Promotion zur Code-Reduzierung
  • Enumerations (Enums): Pure Enums, Backed Enums und Methoden in Enums
  • Match-Expression als typsichere Alternative zu Switch
  • Nullsafe Operator (?->) und Named Arguments (Benannte Parameter)
  • Readonly Properties und Readonly Classes
  • Value Objects: kleine, unveränderliche (immutable) Objekte für fachliche Werte (z. B. Geldbetrag, E-Mail-Adresse) statt primitiver Typen
  • Performance & Benchmarking: Flaschenhälse im Code vermeiden (Referenz: Open-Source-Messskripte PHP-Performance auf GitHub sowie unser Fachartikel PHP-Performance: die acht teuersten Fehler)

Dauer: 3 Tage

Was du danach kannst

  • Software-Architekturen nach SOLID-Prinzipien mit Interfaces, Dependency Injection und loser Kopplung entwerfen
  • Passende Entwurfsmuster (Factory, Strategy, Decorator, Observer u. a.) gezielt statt beliebig einsetzen
  • Unit-Tests mit PHPUnit (Testautomatisierung) schreiben und den Code zusätzlich mit PHPStan/Psalm statisch prüfen
  • Moderne PHP-8-Features (Enums, Readonly, Match, Nullsafe) und Value Objects für stärker typisierten Code nutzen
  • Generatoren und die Reflection API für speichereffiziente bzw. metadatengetriebene Lösungen einsetzen
  • Eigene Exception-Hierarchien entwerfen und Fehler zentral behandeln

Verwandte Seminare

Dein Dozent

Frank Glück schult seit mehr als 30 Jahren und programmiert seit fast 40 Jahren. Seit 1999 ist er auch als Dozent für die GFU tätig.

Häufige Fragen (FAQ)

Welche Entwurfsmuster (Design Patterns) werden im OOP-Seminar behandelt?

Wir konzentrieren uns auf praxisrelevante Muster moderner Webarchitekturen: Factory, Strategy, Dependency Injection, Repository, Decorator und Observer. Du lernst, wie du diese Patterns in PHP 8 mit Interfaces, abstrakten Klassen und Traits sauber implementierst und den Code testbar hältst.

Behandelt das Seminar auch moderne Architekturkonzepte?

Ja. Neben den reinen Sprachfeatures von PHP 8 (Enums, Readonly-Klassen, First-Class Callables, Generatoren) vermitteln wir dir Architektur-Prinzipien wie SOLID, Clean Architecture und Domain-Driven Design (DDD) sowie den Umgang mit Composer-Paketen und PSR-Standards.

Für wen eignet sich dieser Fortgeschrittenenkurs?

Für Entwickler, die bereits mit prozeduralem PHP oder einfachen Klassen arbeiten und ihre Codebasis auf ein wartbares, modulares und zukunftssicheres Enterprise-Niveau heben möchten.

Individuell anfragen

Individuell anfragen