OOP: Inheritance, Interfaces, and Traits in PHP

Table of Contents

• Introduction to Inheritance
• What is Inheritance?
• How to Implement Inheritance in PHP
  • Extending a Class
  • Parent and Child Classes
  • Overriding Methods
• What are Interfaces?
  • Defining an Interface
  • Implementing an Interface in a Class
• What are Traits?
  • Defining a Trait
  • Using Traits in PHP
• Practical Examples
  • Example 1: Inheritance in a Vehicle System
  • Example 2: Using Interfaces for Common Behaviors
  • Example 3: Traits for Code Reusability
• Summary

Introduction to Inheritance, Interfaces, and Traits

Inheritance, interfaces, and traits are advanced concepts in Object-Oriented Programming (OOP) that help create more flexible and reusable code. These features allow PHP developers to build complex systems more efficiently and maintainably.

• Inheritance allows a class to inherit properties and methods from another class, promoting code reuse.
• Interfaces define a contract that classes must follow, ensuring certain methods are implemented by any class that uses the interface.
• Traits are reusable blocks of code that can be included in multiple classes, providing a way to share functionality without the complexities of inheritance.

Each of these features enhances the power and flexibility of OOP, making your PHP codebase more modular and easier to maintain.

What is Inheritance?

Inheritance is one of the key features of OOP, allowing a class to inherit the properties and methods of another class. This promotes code reuse and helps in the creation of a hierarchical structure.

When a class inherits from another class, it can use the properties and methods of the parent class, and it can also define its own unique properties and methods. This avoids code duplication and makes it easier to manage shared functionality.

How to Implement Inheritance in PHP

In PHP, inheritance is implemented using the extends keyword. A child class inherits from a parent class, gaining access to the parent class’s public and protected properties and methods. The child class can also override methods from the parent class.

Extending a Class

To create a child class that extends a parent class, you use the extends keyword.

<?php
class Animal {
    public $name;

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

    public function speak() {
        echo "I am an animal\n";
    }
}

class Dog extends Animal {
    public function speak() {
        echo "Woof! I am a dog\n";
    }
}

// Create a new Dog object
$dog = new Dog("Buddy");
$dog->speak();  // Outputs: Woof! I am a dog
?>

In this example:

• The Dog class extends the Animal class.
• The speak() method is overridden in the Dog class to provide a more specific implementation.

Parent and Child Classes

The parent class contains common behavior, and the child class can either use that behavior or override it. The child class can also add its own unique methods and properties.

Overriding Methods

If a child class has a method with the same name as one in the parent class, the child class’s method will override the parent class’s method. The child class can still call the parent’s method using the parent keyword.

<?php
class Animal {
    public function speak() {
        echo "I am an animal\n";
    }
}

class Dog extends Animal {
    public function speak() {
        parent::speak();
        echo "Woof! I am a dog\n";
    }
}

$dog = new Dog();
$dog->speak();  // Outputs: I am an animal \n Woof! I am a dog
?>

In this case, the Dog class calls the parent’s speak() method using parent::speak() before adding its own functionality.

What are Interfaces?

An interface in PHP defines a contract that a class must adhere to. It specifies a set of methods that the implementing class must define, but it does not provide any implementation itself. Interfaces are used when you want to ensure that multiple classes have the same methods, which can be useful for polymorphism.

An interface can have only method signatures (no method bodies), and the classes that implement the interface must provide the implementation of those methods.

Defining an Interface

<?php
interface Animal {
    public function speak();
}

class Dog implements Animal {
    public function speak() {
        echo "Woof!\n";
    }
}

class Cat implements Animal {
    public function speak() {
        echo "Meow!\n";
    }
}

$dog = new Dog();
$dog->speak();  // Outputs: Woof!

$cat = new Cat();
$cat->speak();  // Outputs: Meow!
?>

In this example:

• The Animal interface defines the speak() method.
• Both Dog and Cat classes implement the Animal interface, ensuring they each provide a specific implementation of the speak() method.

Implementing an Interface in a Class

A class implements an interface using the implements keyword. The class must define all methods declared by the interface.

What are Traits?

A trait is a mechanism for code reuse in PHP. Unlike inheritance, which is based on class hierarchy, traits allow you to include reusable methods in multiple classes. Traits are not meant to be instantiated on their own but are intended to be included in other classes to provide additional functionality.

Defining a Trait

<?php
trait Logger {
    public function log($message) {
        echo "Log: $message\n";
    }
}

class User {
    use Logger;
}

class Admin {
    use Logger;
}

$user = new User();
$user->log("User logged in");  // Outputs: Log: User logged in

$admin = new Admin();
$admin->log("Admin logged in");  // Outputs: Log: Admin logged in
?>

In this example:

• The Logger trait defines a method log().
• Both User and Admin classes use the Logger trait, enabling them to log messages.

Using Traits in PHP

To use a trait in a class, the use keyword is used, followed by the trait name.

Practical Examples

Example 1: Inheritance in a Vehicle System

<?php
class Vehicle {
    public $make;
    public $model;

    public function __construct($make, $model) {
        $this->make = $make;
        $this->model = $model;
    }

    public function displayInfo() {
        echo "Make: $this->make, Model: $this->model\n";
    }
}

class Car extends Vehicle {
    public function displayCarInfo() {
        echo "This is a car: $this->make $this->model\n";
    }
}

$car = new Car("Honda", "Civic");
$car->displayInfo();
$car->displayCarInfo();
?>

In this example:

• Car extends Vehicle, inheriting its properties and methods.
• The Car class adds specific functionality with the displayCarInfo() method.

Example 2: Using Interfaces for Common Behaviors

<?php
interface Shape {
    public function calculateArea();
}

class Circle implements Shape {
    public $radius;

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

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

class Square implements Shape {
    public $sideLength;

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

    public function calculateArea() {
        return pow($this->sideLength, 2);
    }
}

$circle = new Circle(5);
echo "Circle Area: " . $circle->calculateArea() . "\n";

$square = new Square(4);
echo "Square Area: " . $square->calculateArea() . "\n";
?>

This example demonstrates using an interface to define a Shape contract, which is implemented by Circle and Square classes, ensuring they both provide a calculateArea() method.

Example 3: Traits for Code Reusability

<?php
trait Flyable {
    public function fly() {
        echo "Flying...\n";
    }
}

class Bird {
    use Flyable;
}

class Airplane {
    use Flyable;
}

$bird = new Bird();
$bird->fly();

$airplane = new Airplane();
$airplane->fly();
?>

Here, both the Bird and Airplane classes use the Flyable trait, allowing both to “fly” without duplicating code.

Summary

In this module, we explored three important concepts in Object-Oriented Programming (OOP) in PHP: Inheritance, Interfaces, and Traits.

• Inheritance allows a class to inherit properties and methods from another class, enabling code reuse.
• Interfaces define a set of methods that a class must implement, ensuring consistent functionality across different classes.
• Traits are a way to include reusable code in multiple classes, promoting code reusability without the complexities of inheritance.

These powerful OOP features help developers write cleaner, more maintainable, and flexible code.