Difference Between Abstract Class and Interface in PHP OOP

Introduction

In PHP Object-Oriented Programming (OOP), Abstract Classes and Interfaces play a crucial role in designing robust and scalable applications. While both are used to define blueprints for child classes, they have distinct differences and use cases. In this article, we will explore the differences between abstract classes and interfaces with examples.

What is an Abstract Class in PHP?

An Abstract Class is a class that contains atleast one abstruct method. An abstruct method is a method that is declared,but not implemented in the code.

An Abstract Class in PHP is a class that cannot be instantiated directly. It can have both abstract methods (without implementation) and concrete methods (with implementation). Child classes must implement all abstract methods.

Example of Abstract Class in PHP:

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

class Dog extends Animal {
    public function makeSound() {
        echo "Bark";
    }
}

dog = new Dog();
$dog->makeSound(); // Output: Bark
$dog->eat(); // Output: Eating...

Key Features of Abstract Classes:

• Can have both abstract and concrete methods.
• Cannot be instantiated directly.
• Child classes must implement all abstract methods.
• Can have properties and constructors.

What is an Interface in PHP?

An Interface is a blueprint that defines a contract for classes to follow. It can only contain method declarations (without implementation). A class implementing an interface must provide implementations for all its methods.

Example of Interface in PHP:

interface Animal {
    public function makeSound();
}

class Cat implements Animal {
    public function makeSound() {
        echo "Meow";
    }
}

$cat = new Cat();
$cat->makeSound(); // Output: Meow

Key Features of Interfaces:

• Cannot have method implementations, only method declarations.
• A class can implement multiple interfaces (multiple inheritance).
• Cannot have properties.
• All methods are implicitly public.

Real-World Example: Payment System

Let’s take a Payment System as a real-world example.

Using Abstract Class:

abstract class PaymentGateway {
    abstract public function processPayment($amount);
    
    public function validatePayment() {
        echo "Validating payment...";
    }
}

class PayPal extends PaymentGateway {
    public function processPayment($amount) {
        echo "Processing $amount through PayPal";
    }
}

$paypal = new PayPal();
$paypal->processPayment(100);
$paypal->validatePayment();

Using Interface:

interface PaymentProcessor {
    public function processPayment($amount);
}

class Stripe implements PaymentProcessor {
    public function processPayment($amount) {
        echo "Processing $amount through Stripe";
    }
}

class Razorpay implements PaymentProcessor {
    public function processPayment($amount) {
        echo "Processing $amount through Razorpay";
    }
}

$stripe = new Stripe();
$stripe->processPayment(200);

Explanation:

• The abstract class PaymentGateway defines a common behavior (validatePayment()) and enforces processPayment() implementation in child classes.
• The interface PaymentProcessor allows multiple classes (Stripe, Razorpay) to implement the same contract, enabling flexibility and multiple inheritance.

Use an abstract class when you want to force developers working in your system (yourself included) to implement a set numbers of methods and you want to provide some base methods that will help them develop their child classes.

Key Differences Between Abstract Class and Interface

Advantages and Disadvantages

Advantages of Abstract Classes:

• Allows code reusability by defining shared behaviors.
• Can have both abstract and concrete methods, providing flexibility.
• Can have properties and constructors.

Disadvantages of Abstract Classes:

• Does not support multiple inheritance.
• Child classes must extend only one abstract class, limiting flexibility.

Advantages of Interfaces:

• Supports multiple inheritance by allowing a class to implement multiple interfaces.
• Defines a clear contract that multiple classes must follow.
• Encourages better code organization and modularity.

Disadvantages of Interfaces:

• Cannot contain properties or implemented methods, leading to code duplication.
• All methods must be implemented in the implementing class, even if similar functionality exists elsewhere.

When to Use Abstract Class vs Interface?

• Use an abstract class when multiple classes share common behavior.
• Use an interface when you need to define a contract that multiple classes must follow.
• Use an interface for multiple inheritance scenarios.

Conclusion

Both abstract classes and interfaces are essential in PHP OOP. Understanding their differences helps in writing more structured, reusable, and maintainable code. Choose an abstract class when you need shared behavior with some implementation. Opt for an interface when you require multiple inheritance and a strict contract for classes.

I hope this article clarifies the difference between abstract classes and interfaces in PHP. If you have any questions, feel free to comment below!