What is Abstraction?

Abstraction is one of the four fundamental OOP (Object-Oriented Programming) principles, along with encapsulation, inheritance, and polymorphism. In simple terms:

Abstraction hides the internal implementation details and shows only the necessary features of an object.

It allows a developer to define what an object does, without detailing how it does it.


Why Use Abstraction?

Abstraction helps in:

  • Reducing code complexity
  • Improving maintainability
  • Enhancing reusability
  • Enforcing a contract for subclasses

It ensures that subclasses must implement certain methods defined by an abstract class or interface.


Abstraction in PHP

PHP supports abstraction through two features:

1. Abstract Classes

2. Interfaces

1. Abstract Classes in PHP

An abstract class:

  • Cannot be instantiated.
  • May contain both abstract methods (without body) and concrete methods (with body).
  • Serves as a base class that child classes must extend and implement.

Syntax:

abstract class Shape {
    abstract public function area();
    
    public function description() {
        return "This is a shape.";
    }
}

class Circle extends Shape {
    private $radius;

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

    public function area() {
        return pi() * pow($this->radius, 2);
    }
}

$circle = new Circle(5);
echo $circle->area();          // 78.539816339745
echo $circle->description();   // This is a shape.

Key Rules:

  • You cannot create an object of an abstract class directly.
  • Child classes must implement all abstract methods.
  • Abstract classes can have properties, constructors, and non-abstract methods.

2. Interfaces in PHP

An interface:

  • Specifies a contract of what methods a class must implement.
  • Cannot contain any method implementations — only declarations.
  • A class can implement multiple interfaces, allowing multiple inheritance.

🔧 Syntax:

interface Logger {
    public function log($message);
}

class FileLogger implements Logger {
    public function log($message) {
        echo "Logging to file: " . $message;
    }
}

$logger = new FileLogger();
$logger->log("User login successful.");

Key Rules:

  • All methods in interfaces are public by default.
  • Classes must use the implements keyword.
  • Interfaces can extend other interfaces.

Abstract Class vs Interface

FeatureAbstract ClassInterfaceMethod BodyCan have method bodyCannot have method body (PHP <8.0)PropertiesYesNo (until PHP 8.1)Multiple InheritanceNoYes (a class can implement multiple)Use CaseWhen some shared codeWhen only method signatures are needed


⚠️ PHP 8.1+ allows interfaces to have constants and public properties, and PHP 8.0+ allows union types and attributes, making interfaces more powerful.

Real-World Example: Payment Gateway

interface PaymentGateway {

    public function charge($amount);
}

class StripeGateway implements PaymentGateway {
    public function charge($amount) {
        echo "Charging $amount using Stripe.";
    }
}

class PaypalGateway implements PaymentGateway {
    public function charge($amount) {
        echo "Charging $amount using PayPal.";
    }
}

// Usage:
function processPayment(PaymentGateway $gateway, $amount) {
    $gateway->charge($amount);
}

processPayment(new StripeGateway(), 1000); // Charging 1000 using Stripe.

This abstraction allows you to switch gateways (Stripe, PayPal, etc.) without changing business logic.


Best Practices for Using Abstraction

  • Use interfaces when you only need to define method signatures.
  • Use abstract classes when you need base functionality and shared code.
  • Prefer abstraction over tightly coupling business logic to specific classes.
  • Keep the abstraction minimal and meaningful—don’t overengineer!

Conclusion

Abstraction in PHP is a powerful OOP tool that helps create flexible, reusable, and scalable code. Whether you’re building an e-commerce system or a payment API, abstraction lets you separate concerns and build robust architecture.