PHP Abstract Classes

Last modified on: October 20, 2024

<h3>PHP Abstract Classes</h3>
<p>An <strong>abstract class</strong> in PHP is a class that cannot be instantiated directly; it serves as a blueprint for other classes. Abstract classes are typically used when you want to define a common structure for a group of related classes while enforcing the implementation of certain methods in the derived classes.</p>
<p>Abstract classes can contain both regular methods (with implementation) and <strong>abstract methods</strong> (without implementation). Any class that inherits from an abstract class must implement all of its abstract methods.</p>
<hr />
<h3>Defining an Abstract Class</h3>
<p>In PHP, abstract classes are declared using the <code>abstract</code> keyword. Abstract methods are also declared using the <code>abstract</code> keyword, but they do not have a body.</p>
<pre class="language-php"><code>abstract class AbstractClassName {
    abstract public function abstractMethod();
    
    public function concreteMethod() {
        // Implementation of a concrete method
    }
}</code></pre>
<p>In this example, the class <code>Animal</code> is an abstract class with an abstract method <code>makeSound()</code> and a regular method <code>sleep()</code>.</p>
<hr />
<h3>Inheriting an Abstract Class</h3>
<p>To use an abstract class, another class must extend it and implement all of its abstract methods.</p>
<pre class="language-php"><code>abstract class Animal {
    // Abstract method with no implementation
    abstract public function makeSound();

// Concrete method
    public function eat() {
        return "Eating...";
    }
}

// Child class that extends the abstract class
class Dog extends Animal {
    // Implementing the abstract method
    public function makeSound() {
        return "Bark!";
    }
}

// Child class that extends the abstract class
class Cat extends Animal {
    // Implementing the abstract method
    public function makeSound() {
        return "Meow!";
    }
}

$dog = new Dog();
echo $dog-&gt;makeSound(); // Output: Bark!
echo $dog-&gt;eat();       // Output: Eating...

$cat = new Cat();
echo $cat-&gt;makeSound(); // Output: Meow!
echo $cat-&gt;eat();       // Output: Eating...</code></pre>
<p>Here:</p>
<ul>
<li>The <code>Dog</code> and <code>Cat</code> classes extend the <code>Animal</code> abstract class.</li>
<li>Both classes implement the <code>makeSound()</code> method, as required by the abstract class.</li>
<li>They also inherit the <code>sleep()</code> method from the <code>Animal</code> class without needing to redefine it.</li>
</ul>
<hr />
<h3>Key Features of Abstract Classes</h3>
<ol>
<li>
<p><strong>Cannot Be Instantiated</strong>: Abstract classes cannot be used to create objects directly. They are designed to be extended by other classes.</p>
<pre class="language-php"><code>$animal = new Animal(); // Error: Cannot instantiate abstract class</code></pre>
</li>
<li>
<p><strong>Must Implement Abstract Methods</strong>: Any class that inherits from an abstract class must implement all of its abstract methods. If the derived class does not implement these methods, it must also be declared as abstract.</p>
<pre class="language-php"><code>class Bird extends Animal {
    // Error: Must implement makeSound()
}</code></pre>
</li>
<li>
<p><strong>Can Have Regular Methods</strong>: Abstract classes can contain fully implemented methods that can be inherited by child classes.</p>
</li>
<li>
<p><strong>Can Contain Properties</strong>: Abstract classes can define properties, which can be inherited by the child classes.</p>
<pre class="language-php"><code>abstract class Vehicle {
    public function __construct() {
        // Initialization code
    }
}</code></pre>
</li>
</ol>
<hr />
<h3>Abstract Methods</h3>
<p>Abstract methods are defined in an abstract class but have no implementation. The child class must provide the body for these methods.</p>
<pre class="language-php"><code>class Bird extends Animal {
    // Error: Must implement makeSound()
}</code></pre>
<p>In this example:</p>
<ul>
<li><code>Shape</code> is an abstract class that defines an abstract method <code>area()</code>.</li>
<li><code>Circle</code> extends <code>Shape</code> and provides the implementation for the <code>area()</code> method.</li>
</ul>
<hr />
<h3>Real-World Example: Payment Processing</h3>
<p>A common use case for abstract classes is when you have different payment methods (e.g., PayPal, Stripe, etc.) that share common functionality but also have some differences.</p>
<pre class="language-php"><code>abstract class Shape {
    protected $color;

public function __construct($color) {
        $this-&gt;color = $color;
    }

abstract public function area(); // Abstract method
}

class Rectangle extends Shape {
    private $width;
    private $height;

public function __construct($color, $width, $height) {
        parent::__construct($color); // Call the parent constructor
        $this-&gt;width = $width;
        $this-&gt;height = $height;
    }

public function area() {
        return $this-&gt;width * $this-&gt;height; // Implementing the abstract method
    }
}

$rectangle = new Rectangle("blue", 5, 10);
echo $rectangle-&gt;area(); // Output: 50</code></pre>
<p>Here:</p>
<ul>
<li>The abstract class <code>Payment</code> defines a common structure for payment processing.</li>
<li><code>PayPal</code> and <code>Stripe</code> classes implement their own versions of the <code>processPayment()</code> method, while inheriting the <code>sendReceipt()</code> method from the <code>Payment</code> class.</li>
</ul>
<hr />
<h3>Advantages of Abstract Classes</h3>
<ol>
<li><strong>Code Reusability</strong>: Abstract classes allow you to define common functionality that multiple child classes can inherit.</li>
<li><strong>Enforcing Structure</strong>: They enforce that certain methods must be implemented by child classes, providing a consistent interface.</li>
<li><strong>Flexibility</strong>: Child classes can extend the functionality of abstract classes and add their own unique behavior.</li>
</ol>
<hr />
<h3>When to Use Abstract Classes</h3>
<ul>
<li>When you want to create a base class that outlines common functionality while forcing child classes to implement certain methods.</li>
<li>When you need a class to share common logic but still allow for variation in certain behaviors.</li>
<li>When you need a blueprint for future extensions but don't want the class to be instantiated on its own.</li>
</ul>
<hr />
<h3>Abstract Class vs Interface</h3>
<p>Though both abstract classes and interfaces are used to define blueprints for other classes, they have some differences:</p>
<table>
<thead>
<tr>
<th>Feature</th>
<th>Abstract Class</th>
<th>Interface</th>
</tr>
</thead>
<tbody>
<tr>
<td>Method Implementation</td>
<td>Can contain both abstract and concrete methods</td>
<td>Cannot have any implemented methods (prior to PHP 8)</td>
</tr>
<tr>
<td>Constructor</td>
<td>Can have a constructor</td>
<td>Cannot have a constructor</td>
</tr>
<tr>
<td>Multiple Inheritance</td>
<td>Can extend only one class</td>
<td>A class can implement multiple interfaces</td>
</tr>
<tr>
<td>Access Modifiers</td>
<td>Can have properties and methods with visibility (<code>public</code>, <code>protected</code>, <code>private</code>)</td>
<td>All methods must be <code>public</code></td>
</tr>
</tbody>
</table>
<hr />
<h3>&nbsp;</h3>

Web Technology View More