Advanced OOP Patterns 🏗️

Master the Factory, Singleton, Strategy, and Repository patterns — the building blocks of professional PHP architecture.

What You'll Learn in This Lesson

• Singleton: guarantee one instance of a class across your app
• Factory: create objects without hardcoding which class to instantiate
• Strategy: swap algorithms at runtime without changing client code
• Repository: abstract data access behind a clean interface
• When to use (and when NOT to use) each pattern

Note: PHP runs on a server. Our examples simulate PHP logic using JavaScript. To run real PHP, install PHP.

🎯 Real-World Analogy: Think of design patterns like architectural blueprints. A Singleton is like having one power grid for the whole city — everyone shares it. A Factory is like an assembly line — you say "make a car" and the factory handles the details. A Strategy is like GPS navigation — you choose the route (fastest, shortest, scenic) but the car drives the same way. A Repository is like a librarian — you ask for a book and they find it, whether it's on a shelf, in storage, or on loan.

Singleton & Factory Patterns

The Singleton ensures only one instance of a class exists — perfect for database connections and configuration managers. The Factory pattern lets you create objects without specifying their exact class, making your code flexible and extensible. Both are "creational" patterns from the Gang of Four (GoF) book.

Try It: Singleton & Factory

See how Singleton shares state and Factory creates different notification types

Try it Yourself »

JavaScript

// PHP Design Patterns: Singleton & Factory
console.log("=== SINGLETON PATTERN ===");
console.log();
console.log("Purpose: Ensure a class has only ONE instance globally");
console.log("Use case: Database connections, config managers, loggers");
console.log();

// Simulate Singleton in JS
class Database {
  static instance = null;
  constructor() {
    if (Database.instance) return Database.instance;
    this.connection = "MySQL connection established";
    this.queryCount = 0;
    Database.insta
...

Strategy & Repository Patterns

The Strategy pattern encapsulates algorithms so you can swap them at runtime — ideal for pricing rules, sorting methods, or validation strategies. The Repository pattern abstracts data access behind an interface, so your business logic doesn't care whether data comes from MySQL, an API, or a file. Both patterns make your code testable and maintainable.

Try It: Strategy & Repository

Apply different pricing strategies and use a Repository to manage users

Try it Yourself »

JavaScript

// PHP Design Patterns: Strategy & Repository
console.log("=== STRATEGY PATTERN ===");
console.log();
console.log("Purpose: Define a family of algorithms and make them interchangeable");
console.log("Use case: Sorting, pricing rules, discount calculations");
console.log();

// Different pricing strategies
const strategies = {
  regular: (price) => price,
  member: (price) => price * 0.9,
  vip: (price) => price * 0.8,
  bulk: (price, qty) => qty >= 10 ? price * 0.7 : price,
};

let items = [
  {
...

⚠️ Common Mistakes

⚠️

Overusing Singleton — it introduces global state, which makes testing harder. Prefer dependency injection and only use Singleton for truly shared resources like DB connections.

⚠️

Factory with too many types — if your factory has 20+ branches, consider using a registry or configuration-based approach instead of a giant switch statement.

⚠️

Leaking implementation details — a Repository should never expose SQL queries or database-specific logic. Keep the interface clean and abstract.

💡

Pro Tip: Start without patterns. When you notice duplication, tight coupling, or hard-to-test code, THEN apply the appropriate pattern. Premature abstraction is worse than no abstraction.

📋 Quick Reference — OOP Patterns

Pattern	Type	When to Use
Singleton	Creational	One shared instance (DB, config)
Factory	Creational	Create objects by type string
Strategy	Behavioral	Swap algorithms at runtime
Repository	Structural	Abstract data access layer

🎉 Lesson Complete!

You now know four essential design patterns! Next, learn about Dependency Injection Containers — the key to building testable, decoupled PHP applications.