Object-Oriented Programming (OOP) in PHP isn't just about classes and objects. It’s about making your code cleaner, reusable, and modular. Inheritance and Interfaces help you do just that!
🎯 In this guide, you’ll learn:
✅ What inheritance is and how it works
✅ How interfaces enforce consistency in your code
✅ How to use abstract classes
✅ A real-world example using OOP principles
Let’s dive in! 🚀
1️⃣ What Is Inheritance in PHP?
💡 Inheritance lets one class reuse properties and methods from another class.
🔹 Parent Class = The original class (Base class).
🔹 Child Class = The class that extends the parent class (Derived class).
Example: Basic Inheritance
<?php
class Animal {
public $name;
public function __construct($name) {
$this->name = $name;
}
public function makeSound() {
return "$this->name makes a sound.";
}
}
// Dog class inherits from Animal
class Dog extends Animal {
public function makeSound() {
return "$this->name barks.";
}
}
$dog = new Dog("Buddy");
echo $dog->makeSound(); // Output: Buddy barks.
?>
🔥 What’s happening?
✅ Dog class inherits from Animal (extends Animal).
✅ It overrides the makeSound() method.
2️⃣ Overriding Parent Methods
If a child class needs a different behavior, it can override the parent’s method.
Example: Overriding a Method
<?php
class Car {
public function drive() {
return "The car is moving.";
}
}
class Tesla extends Car {
public function drive() {
return "The Tesla is driving autonomously!";
}
}
$myCar = new Tesla();
echo $myCar->drive(); // Output: The Tesla is driving autonomously!
?>
🔥 Why override methods?
✅ Allows customization without modifying the original class.
3️⃣ Using parent:: to Call Parent Methods
Even if you override a method, you can still call the parent method.
<?php
class Person {
public function greet() {
return "Hello!";
}
}
class Student extends Person {
public function greet() {
return parent::greet() . " I'm a student!";
}
}
$student = new Student();
echo $student->greet(); // Output: Hello! I'm a student!
?>
🔥 Why use parent::?
✅ Keeps the original behavior but adds extra functionality.
4️⃣ Understanding Abstract Classes
💡 Abstract classes are blueprints for other classes.
🔹 They cannot be instantiated.
🔹 They must be extended by other classes.
🔹 They can define abstract methods (methods that must be implemented by child classes).
Example: Using an Abstract Class
<?php
abstract class Vehicle {
abstract public function move(); // Must be implemented by child classes
}
class Bike extends Vehicle {
public function move() {
return "The bike is pedaling.";
}
}
class Car extends Vehicle {
public function move() {
return "The car is driving.";
}
}
$bike = new Bike();
echo $bike->move(); // Output: The bike is pedaling.
$car = new Car();
echo $car->move(); // Output: The car is driving.
?>
🔥 Why use abstract classes?
✅ Enforces a common structure for all child classes.
✅ Ensures that all vehicles must have a move() method.
5️⃣ What Are Interfaces?
💡 Interfaces define a set of methods that a class must implement.
🔹 Unlike abstract classes, interfaces cannot have properties.
🔹 A class can implement multiple interfaces, but it can only extend one class.
Example: Using Interfaces
<?php
interface PaymentGateway {
public function processPayment($amount);
}
class PayPal implements PaymentGateway {
public function processPayment($amount) {
return "Processing $$amount payment through PayPal.";
}
}
class Stripe implements PaymentGateway {
public function processPayment($amount) {
return "Processing $$amount payment through Stripe.";
}
}
$paypal = new PayPal();
echo $paypal->processPayment(100); // Output: Processing $100 payment through PayPal.
$stripe = new Stripe();
echo $stripe->processPayment(200); // Output: Processing $200 payment through Stripe.
?>
🔥 Why use interfaces?
✅ Enforces consistency (every payment gateway must have processPayment()).
✅ Supports multiple implementations of the same functionality.
6️⃣ Abstract Class vs. Interface: Key Differences
| Feature | Abstract Class | Interface |
|---|---|---|
| Properties | ✅ Can have properties | ❌ Cannot have properties |
| Method Implementation | ✅ Can have implemented methods | ❌ Only method signatures |
| Multiple Inheritance | ❌ No (one parent class) | ✅ Yes (multiple interfaces) |
| Use Case | When you want some shared behavior | When you want only method requirements |
🎯 Mini Project: Employee Management System
Let’s build an OOP-based Employee System using inheritance and interfaces.
1️⃣ Abstract Employee Class
<?php
abstract class Employee {
protected $name;
protected $salary;
public function __construct($name, $salary) {
$this->name = $name;
$this->salary = $salary;
}
abstract public function getRole(); // Must be implemented by child classes
public function getDetails() {
return "$this->name earns $$this->salary.";
}
}
?>
2️⃣ Child Classes (Manager & Developer)
<?php
require "Employee.php";
class Manager extends Employee {
public function getRole() {
return "Manager";
}
}
class Developer extends Employee {
public function getRole() {
return "Developer";
}
}
?>
3️⃣ Payroll Interface
<?php
interface Payroll {
public function calculateBonus();
}
class SeniorDeveloper extends Developer implements Payroll {
public function calculateBonus() {
return $this->salary * 0.1; // 10% bonus
}
}
?>
4️⃣ Testing the System
<?php
require "Manager.php";
require "Developer.php";
require "SeniorDeveloper.php";
$manager = new Manager("Alice", 6000);
$dev = new Developer("Bob", 5000);
$seniorDev = new SeniorDeveloper("Charlie", 7000);
echo $manager->getDetails() . " Role: " . $manager->getRole() . "<br>";
echo $dev->getDetails() . " Role: " . $dev->getRole() . "<br>";
echo $seniorDev->getDetails() . " Role: " . $seniorDev->getRole() . ". Bonus: $" . $seniorDev->calculateBonus();
?>
🔥 What’s happening?
✅ Managers and Developers inherit Employee properties
✅ SeniorDeveloper implements a Payroll system
✅ This structure follows real-world job roles
🚀 Final Thoughts
Now you understand inheritance, interfaces, and abstract classes!
✅ Use inheritance to avoid code duplication.
✅ Use abstract classes to enforce a base structure.
✅ Use interfaces when you need multiple implementations.
👉 Next: PHP Namespaces
Happy coding! 🎉🚀