The Project | About Us | Contribute | Donations | License

HOME

In this section, we will explore two fundamental concepts in Object-Oriented Programming (OOP) in PHP: Interfaces and Abstract Classes. These concepts are crucial for designing robust and scalable applications.

What are Interfaces?

An interface in PHP is a contract that defines a set of methods that a class must implement. Interfaces allow you to specify what methods a class should have, without providing the implementation of those methods.

Key Points:

Interfaces define the methods a class must implement.
Interfaces cannot contain any implementation.
A class can implement multiple interfaces.

Syntax:

interface InterfaceName {
    public function method1();
    public function method2($param);
}

Example:

interface Logger {
    public function log($message);
}

class FileLogger implements Logger {
    public function log($message) {
        echo "Logging message to a file: $message";
    }
}

class DatabaseLogger implements Logger {
    public function log($message) {
        echo "Logging message to a database: $message";
    }
}

$fileLogger = new FileLogger();
$fileLogger->log("File log message");

$databaseLogger = new DatabaseLogger();
$databaseLogger->log("Database log message");

Explanation:

We define an interface Logger with a method log.
FileLogger and DatabaseLogger classes implement the Logger interface.
Both classes provide their own implementation of the log method.

What are Abstract Classes?

An abstract class in PHP is a class that cannot be instantiated on its own and is meant to be subclassed. Abstract classes can contain both abstract methods (methods without implementation) and concrete methods (methods with implementation).

Key Points:

Abstract classes cannot be instantiated.
Abstract classes can contain both abstract and concrete methods.
A class can extend only one abstract class.

Syntax:

abstract class AbstractClass {
    abstract protected function abstractMethod();
    
    public function concreteMethod() {
        echo "This is a concrete method.";
    }
}

Example:

abstract class Animal {
    abstract public function makeSound();
    
    public function sleep() {
        echo "Sleeping...";
    }
}

class Dog extends Animal {
    public function makeSound() {
        echo "Bark";
    }
}

class Cat extends Animal {
    public function makeSound() {
        echo "Meow";
    }
}

$dog = new Dog();
$dog->makeSound(); // Outputs: Bark
$dog->sleep(); // Outputs: Sleeping...

$cat = new Cat();
$cat->makeSound(); // Outputs: Meow
$cat->sleep(); // Outputs: Sleeping...

Explanation:

We define an abstract class Animal with an abstract method makeSound and a concrete method sleep.
Dog and Cat classes extend the Animal class and provide their own implementation of the makeSound method.
We can create instances of Dog and Cat and call their methods.

Practical Exercise

Task:

Create an interface Shape with methods area and perimeter. Then, create two classes Circle and Rectangle that implement the Shape interface.

Solution:

interface Shape {
    public function area();
    public function perimeter();
}

class Circle implements Shape {
    private $radius;

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

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

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

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

    public function __construct($width, $height) {
        $this->width = $width;
        $this->height = $height;
    }

    public function area() {
        return $this->width * $this->height;
    }

    public function perimeter() {
        return 2 * ($this->width + $this->height);
    }
}

$circle = new Circle(5);
echo "Circle Area: " . $circle->area() . "\n"; // Outputs: Circle Area: 78.539816339745
echo "Circle Perimeter: " . $circle->perimeter() . "\n"; // Outputs: Circle Perimeter: 31.415926535897

$rectangle = new Rectangle(4, 7);
echo "Rectangle Area: " . $rectangle->area() . "\n"; // Outputs: Rectangle Area: 28
echo "Rectangle Perimeter: " . $rectangle->perimeter() . "\n"; // Outputs: Rectangle Perimeter: 22

Explanation:

We define an interface Shape with methods area and perimeter.
Circle and Rectangle classes implement the Shape interface and provide their own implementations for the area and perimeter methods.
We create instances of Circle and Rectangle and call their methods to calculate the area and perimeter.

Summary

In this section, we learned about interfaces and abstract classes in PHP. Interfaces define a contract that classes must follow, while abstract classes provide a base for other classes to extend. Both concepts are essential for designing flexible and maintainable code. In the next section, we will delve into traits, another powerful feature in PHP OOP.

Interfaces and Abstract Classes

What are Interfaces?

Key Points:

Syntax:

Example:

Explanation:

What are Abstract Classes?

Key Points:

Syntax:

Example:

Explanation:

Practical Exercise

Task:

Solution:

Explanation:

Summary

PHP Programming Course

Module 1: Introduction to PHP

Module 2: Control Structures

Module 3: Functions

Module 4: Arrays

Module 5: Working with Forms

Module 6: Working with Files

Module 7: Object-Oriented Programming (OOP)

Module 8: Working with Databases

Module 9: Advanced PHP Techniques

Module 10: PHP Frameworks and Best Practices

Module 11: Project: Building a Web Application