OOP With PHP 4: Advanced OOP Concepts In PHP

Object-Oriented Programming (OOP) in PHP provides powerful tools to build maintainable and reusable code. In this blog, we will explore three advanced OOP concepts in PHP:

1. Abstraction – Using abstract classes to define a blueprint for derived classes.

2. Interfaces – Implementing multiple behaviors in PHP classes.

3. Traits – Solving the multiple inheritance problem.

1. Abstraction in PHP: Abstract Classes & Their Usage

What is Abstraction?

Abstraction is a principle that allows defining a blueprint for a class while leaving the implementation details to the child classes. In PHP, abstract classes cannot be instantiated and must be extended by child classes.

Example:

abstract class Vehicle {
    protected $speed;

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

    // Abstract method - must be implemented in child classes
    abstract public function move();
}

class Car extends Vehicle {
    public function move() {
        return "The car moves at a speed of {$this->speed} km/h";
    }
}

$car = new Car(80);
echo $car->move();

Key Takeaways:

• Abstract classes can have both abstract and concrete methods.

• Child classes must implement all abstract methods.

• Cannot instantiate an abstract class directly.

2. Interfaces in PHP: Implementing Multiple Behaviors

What is an Interface?

An interface defines a contract that classes must follow. Unlike abstract classes, an interface cannot have properties or concrete methods—only method signatures.

Example:

interface Drivable {
    public function start();
    public function stop();
}

interface Flyable {
    public function fly();
}

class FlyingCar implements Drivable, Flyable {
    public function start() {
        return "The flying car starts.";
    }
    
    public function stop() {
        return "The flying car stops.";
    }
    
    public function fly() {
        return "The flying car is flying.";
    }
}

$flyingCar = new FlyingCar();
echo $flyingCar->start() . "<br>";
echo $flyingCar->fly() . "<br>";
echo $flyingCar->stop();

Key Takeaways:

• Interfaces enforce method implementation in classes.

• A class can implement multiple interfaces (unlike abstract classes, which can only be extended by one class).

• Methods in an interface must be public.

trait Logger {
    public function log($message) {
        echo "Logging message: $message <br>";
    }
}

trait Notifier {
    public function notify($user) {
        echo "Notifying user: $user <br>";
    }
}

class Application {
    use Logger, Notifier;

    public function run() {
        $this->log("Application started");
        $this->notify("Admin");
    }
}

$app = new Application();
$app->run();