PHP OOP – Abstract Classes

Welcome to The Coding College! In this tutorial, we’ll dive into abstract classes in PHP Object-Oriented Programming (OOP). Abstract classes are a cornerstone of building structured and extensible applications, especially when dealing with complex hierarchies.

What is an Abstract Class?

An abstract class in PHP is a special type of class that cannot be instantiated directly. It serves as a blueprint for other classes. Abstract classes can:

• Define properties and methods that child classes must inherit.
• Contain abstract methods (methods without a body) that must be implemented in child classes.

Key Features of Abstract Classes

1. Cannot Be Instantiated: You cannot create objects from an abstract class directly.
2. Abstract Methods: These are methods declared without a body in the abstract class and must be implemented in the derived class.
3. Non-Abstract Methods: Abstract classes can also include fully implemented methods.
4. Supports Inheritance: Abstract classes are meant to be extended by child classes.

Syntax of Abstract Classes

To declare an abstract class in PHP, use the abstract keyword before the class keyword. Abstract methods within the class also require the abstract keyword.

<?php
abstract class AbstractClass {
    // Abstract method (must be implemented in child class)
    abstract public function abstractMethod();

    // Non-abstract method (optional to override in child class)
    public function regularMethod() {
        echo "This is a regular method in the abstract class.<br>";
    }
}
?>

Example: Abstract Class and Abstract Method

Let’s see how abstract classes and methods work together:

<?php
// Abstract class
abstract class Animal {
    // Abstract method
    abstract public function makeSound();

    // Non-abstract method
    public function move() {
        echo "The animal moves.<br>";
    }
}

// Child class that inherits the abstract class
class Dog extends Animal {
    // Implementing the abstract method
    public function makeSound() {
        echo "The dog barks.<br>";
    }
}

$dog = new Dog();
$dog->makeSound(); // Output: The dog barks.
$dog->move();      // Output: The animal moves.
?>

Explanation:

1. The Animal class is declared abstract and cannot be instantiated.
2. The makeSound method is abstract, so the child class (Dog) must implement it.
3. The move method is a regular method and is inherited by the child class.

Why Use Abstract Classes?

Abstract classes are useful when:

• You want to define a base class with common properties or methods.
• You need to enforce that child classes implement specific methods.
• You want to create a template for related classes that share functionality but may implement some details differently.

Abstract Classes vs Interfaces

Although abstract classes and interfaces may seem similar, they serve different purposes.

Real-World Example: Abstract Classes

Let’s consider a payment system where different payment methods share common functionality but handle payments differently.

<?php
abstract class Payment {
    abstract public function processPayment($amount);

    public function paymentDetails($amount) {
        echo "Processing a payment of $$amount.<br>";
    }
}

class CreditCardPayment extends Payment {
    public function processPayment($amount) {
        echo "Payment of $$amount made using Credit Card.<br>";
    }
}

class PayPalPayment extends Payment {
    public function processPayment($amount) {
        echo "Payment of $$amount made using PayPal.<br>";
    }
}

$creditCard = new CreditCardPayment();
$creditCard->paymentDetails(100); // Output: Processing a payment of $100.
$creditCard->processPayment(100); // Output: Payment of $100 made using Credit Card.

$paypal = new PayPalPayment();
$paypal->paymentDetails(50);      // Output: Processing a payment of $50.
$paypal->processPayment(50);      // Output: Payment of $50 made using PayPal.
?>

Access Modifiers in Abstract Methods

Abstract methods must follow the same or stricter access levels in child classes. For example:

• A protected abstract method can only be protected or public in the child class.
• A public abstract method must remain public.

Example: Access Modifiers

<?php
abstract class ParentClass {
    abstract protected function show();
}

class ChildClass extends ParentClass {
    protected function show() {
        echo "This is the child class implementation.<br>";
    }
}

$child = new ChildClass();
$child->show(); // Output: This is the child class implementation.
?>

Preventing Child Class Instantiation

If you want to ensure that child classes cannot be instantiated directly, you can combine abstract classes with final methods.

Example: Preventing Child Instantiation

<?php
abstract class AbstractClass {
    abstract public function requiredMethod();

    final public function commonMethod() {
        echo "This is a final method and cannot be overridden.<br>";
    }
}

class ConcreteClass extends AbstractClass {
    public function requiredMethod() {
        echo "This is the required method implementation.<br>";
    }
}

$object = new ConcreteClass();
$object->commonMethod();  // Output: This is a final method and cannot be overridden.
$object->requiredMethod(); // Output: This is the required method implementation.
?>

Advantages of Abstract Classes

1. Code Reusability: Define common functionality in the base class.
2. Enforcement: Ensure child classes implement specific methods.
3. Extensibility: Allow flexibility for child classes to define their unique behavior.

Limitations of Abstract Classes

1. Single Inheritance: A child class can inherit only one abstract class.
2. Not Always Necessary: If you only need method declarations, an interface might be a better choice.

Best Practices

1. Use abstract classes when you need to share common logic across related classes.
2. Name abstract classes meaningfully (e.g., Payment, Animal).
3. Avoid including too much logic in abstract classes; keep them focused and clean.
4. Combine abstract methods with regular methods for flexibility.

Conclusion

Abstract classes in PHP provide a powerful way to create templates for other classes, combining enforcement of required methods with reusable logic. By mastering abstract classes, you can design scalable and organized applications.

To learn more about PHP OOP and improve your programming skills, visit The Coding College.