Introduction: Why Use Abstract Classes in PHP?

When building object-oriented applications in PHP, you often encounter situations where you want to define a blueprint, but not allow direct instantiation. For example, you might want to force all subclasses to implement specific behavior while still sharing some base logic.

This is where abstract classes come in.

Abstract classes provide a way to:

• Enforce method contracts via abstract methods.

• Share common functionality across child classes.

• Prevent instantiation of incomplete base classes.

Using abstract classes makes your code more maintainable, consistent, and scalable.

What Is an Abstract Class in PHP?

An abstract class is a class that cannot be instantiated on its own and is meant to be extended by other classes. It can contain both:

• Abstract methods (declared but not defined).

• Regular methods (with implementation).

abstract class Animal {
    abstract public function makeSound(); // Abstract method
    public function eat() {
        echo "Eating...\n";
    }
}

Defining Abstract Classes and Methods

Syntax

abstract class ClassName {
    abstract public function methodName();
}

✅ Rules

• Must use the abstract keyword.

• Abstract methods cannot have a body.

• Child classes must implement all abstract methods.

• You cannot create an object of an abstract class.

Abstract Class vs Interface (Quick Comparison)

Complete Example: Abstract Class in Action

<?php
// Abstract class with one abstract method and one concrete method
abstract class Vehicle {
    protected $brand;

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

    // Abstract method (must be implemented)
    abstract public function startEngine();

    // Concrete method
    public function getBrand() {
        return $this->brand;
    }
}

// Subclass implements the abstract method
class Car extends Vehicle {
    public function startEngine() {
        echo "Starting engine of {$this->brand} car...\n";
    }
}

// Subclass implements the abstract method
class Bike extends Vehicle {
    public function startEngine() {
        echo "Starting engine of {$this->brand} bike...\n";
    }
}

$car = new Car("Toyota");
$bike = new Bike("Yamaha");

$car->startEngine();    // Output: Starting engine of Toyota car...
$bike->startEngine();   // Output: Starting engine of Yamaha bike...
?>

Tips & Common Pitfalls

✅ Best Practices

• Use abstract classes for base models, services, or controllers in your app.

• Keep abstract classes focused—avoid putting too much logic.

• Document abstract methods well to guide implementers.

❌ Common Mistakes

• Trying to instantiate an abstract class directly.

• Forgetting to implement all abstract methods in the child class.

• Providing a body for abstract methods (syntax error).

Real-World Use Cases

• Framework base controllers (e.g., Laravel’s Controller class).

• Service layers where certain processes need common logic with custom steps.

• Adapter patterns where subclasses provide different implementations.

Advanced Tip: Combine with Interfaces

interface Drivable {
    public function drive();
}

abstract class Vehicle {
    abstract public function startEngine();
}

class Truck extends Vehicle implements Drivable {
    public function startEngine() {
        echo "Truck engine started\n";
    }

    public function drive() {
        echo "Driving the truck\n";
    }
}

This allows you to enforce structure while still keeping flexibility with interfaces.

Conclusion: Power Up Your OOP with Abstract Classes

PHP abstract classes are essential for designing flexible, reusable, and organized code. They let you define a shared blueprint while allowing customization in subclasses.

Key Takeaways

• Use abstract classes when you want to define a common base structure.

• Combine abstract classes with interfaces for cleaner design.

• Keep logic DRY and your app architecture scalable.