Interfaces is one of the core concepts in object-oriented programming (OOP) in PHP. It improves decoupling, abstraction, and polymorphism, which increases the flexibility and reusability of code. The class that is fully abstract is called interface. In this article, we will explore PHP interfaces in detail, covering their syntax, benefits, use cases, and best practices.
What is an Interface in PHP?
In PHP, an interface provides a blueprint for classes that use it. Interfaces specify method signatures that must be implemented by the classes that utilize them; they do not contain any actual methods, in contrast to abstract classes. We use interface keyword to declare an Interface.
Syntax:
interface InterfaceName
{
public function method1();
public function method2($param);
}
All of the methods specified in the interface must be defined by the class that implements it:
class MyClass implements InterfaceName
{
public function method1()
{
echo "Method1 implemented";
}
public function method2($param)
{
echo "Method2 implemented with param: $param";
}
}
$object = new MyClass();
$object->method1();
$object->method2("Test");
interface InterfaceName
{
public function method1();
public function method2($param);
}
All of the methods specified in the interface must be defined by the class that implements it:
class MyClass implements InterfaceName
{
public function method1()
{
echo "Method1 implemented";
}
public function method2($param)
{
echo "Method2 implemented with param: $param";
}
}
$object = new MyClass();
$object->method1();
$object->method2("Test");
Why Use Interfaces?
Interfaces play an important role in OOPs concept for the following reasons:
- Code Reusability: Code reuse is maximized since interface can be impemented by multiple classes.
- Abstraction: Interface does not show implementation details, it only shows necessary functionalities.
- Polymorphism: The ability to use various classes interchangeably through a shared interface.
- Modularity: When concerns are separated, applications become more modular and easier to maintain.
- Flexibility: Because alternative implementations of the same set of behaviors are permitted, interfaces offer flexibility.
Key Features of Interfaces
- Method Without Body: Interfaces contain only those methods who don't have method body.
- Multiple Interface Implementation: A class can inherit from only one parent class but can implement multiple interfaces.
- No Properties define: Interfaces cannot contain any properties.
- Forcing Implementation: Every class that implements an interface needs to define all its methods.
Implementing Multiple Interfaces
A single class can implement multiple interfaces.
interface InterfaceA
{
public function methodA();
}
interface InterfaceB
{
public function methodB();
}
class MultiInterfaceClass implements InterfaceA, InterfaceB
{
public function methodA()
{
echo "MethodA from InterfaceA";
}
public function methodB()
{
echo "MethodB from InterfaceB";
}
}
$multi = new MultiInterfaceClass();
$multi->methodA();
$multi->methodB();
Difference Between Interface & Abstract class
| Interfaces | Abstract Class |
| The abstract modifier cannot be used in an interface. | The abstract modifier is required for an abstract class. |
| Public, Protected, and Private access modifiers cannot be used on an interface. | Private, protected, and public access modifiers cannot be used by an abstract class. |
| Interface modifiers can be used to declare an interface. | Abstract and class modifiers can be used to declare an abstract class. |
| Public, protected, private, static, and final variables cannot be declared using interfaces. | Private, protected, and final methods can be declared and defined by an abstract class. |
| Private, protected, and final methods cannot be declared by interfaces. | It can declare and define private, protected, and final methods. |
| Interfaces are always 100% abstract. | If every method declared in an abstract class is abstract, the class can be 100% abstract. |
| Multiple inheritance is possible using interfaces. |
When to Use an Interface Over an Abstract Class
We use Interface, When we require several classes to adhere to a contract without exchanging implementation information.
We use Abstract Class, If we need to allow method overriding while sharing common functionality.
Real-World Examples
Example 1:
interface Logger
{
public function log($message);
}
class FileLogger implements Logger
{
public function log($message)
{
file_put_contents("log.txt", $message . "\n", FILE_APPEND);
}
}
class DatabaseLogger implements Logger
{
public function log($message)
{
// Code to store log in database
echo "Log stored in database: $message";
}
}
class UserService
{
private $logger;
public function __construct(Logger $logger)
{
$this->logger = $logger;
}
public function registerUser($username)
{
// Register user logic
$this->logger->log("User $username registered");
}
}
$userService = new UserService(new FileLogger());
$userService->registerUser("JohnDoe");
Example 2:
interface PaymentStrategy
{
public function pay($amount);
}
class PayPalPayment implements PaymentStrategy
{
public function pay($amount)
{
echo "Paid $amount using PayPal.";
}
}
class CreditCardPayment implements PaymentStrategy
{
public function pay($amount)
{
echo "Paid $amount using Credit Card.";
}
}
class ShoppingCart
{
private $paymentMethod;
public function __construct(PaymentStrategy $paymentMethod)
{
$this->paymentMethod = $paymentMethod;
}
public function checkout($amount)
{
$this->paymentMethod->pay($amount);
}
}
$cart = new ShoppingCart(new PayPalPayment());
$cart->checkout(100);
Conclusion
A great tool for organizing code and guaranteeing consistency between several implementations are PHP interfaces. They encourage loose coupling, modularity, and reuse, making them critical for scalable and maintainable programs. Understanding when and how to use interfaces enables you to develop cleaner, more efficient PHP code.
