Difference Between abstract class and interface in PHP
In PHP, both abstract classes and interfaces are used to define structures for other classes to follow, but they serve different purposes and have distinct characteristics. Understanding when to use an abstract class versus an interface is crucial for designing a well-structured and flexible object-oriented system. Let’s explore the differences between these two concepts.
1. Definition
Abstract Class:
An abstract class is a class that cannot be instantiated on its own and is intended to be extended by other classes. It may contain both abstract methods (methods without implementations) and concrete methods (methods with implementations). Abstract classes allow you to define a common base class for a group of related classes, with some shared functionality and some methods that must be implemented by the derived classes.
Interface:
An interface is a contract that defines a set of methods that a class must implement, but unlike an abstract class, it cannot contain any method implementations (in PHP, prior to version 8, interfaces couldn’t have any implementation, though PHP 8 introduced default methods in interfaces). Interfaces focus purely on the structure (the methods that should exist) and leave the implementation to the class.
2. Purpose
- Abstract Class: Used when you have a base class that should provide default behavior or share some common functionality among subclasses but still allow subclasses to define some of their behavior.
- Interface: Used to define a set of methods that unrelated classes must implement. Interfaces are ideal for defining common behaviors across classes that do not share a common ancestor.
3. Method Implementation
Abstract Class:
- Can have both abstract methods (without implementation) and concrete methods (with implementation).
- Abstract methods must be implemented by any subclass, but concrete methods can be inherited as-is or overridden.
Interface:
- Can only declare method signatures (methods without bodies), leaving the implementation to the classes.
- PHP 8 allows interfaces to have default methods, which means you can provide an implementation, but the class can still override it.
Example:
// Abstract Class
abstract class Animal {
abstract public function makeSound(); // Abstract method
public function sleep() {
echo "Sleeping..."; // Concrete method
}
}
// Interface
interface AnimalInterface {
public function makeSound(); // Only method signature
public function eat(); // Only method signature
}
4. Inheritance vs. Implementation
Abstract Class:
- A class can extend only one abstract class because PHP does not support multiple inheritance.
- A subclass inherits both the abstract and concrete methods of the abstract class.
Interface:
- A class can implement multiple interfaces. This is PHP’s way of supporting multiple inheritance for behavior (though not for implementation).
Example:
// Abstract Class Example
abstract class Bird {
abstract public function fly();
}
class Sparrow extends Bird {
public function fly() {
echo "Sparrow is flying";
}
}
// Interface Example
interface Flyable {
public function fly();
}
interface Eatable {
public function eat();
}
class Sparrow implements Flyable, Eatable {
public function fly() {
echo "Sparrow is flying";
}
public function eat() {
echo "Sparrow is eating";
}
}
5. Properties
Abstract Class:
- An abstract class can have properties (variables) with default values. These properties can be inherited by child classes.
Interface:
- An interface cannot have properties. It can only define method signatures, constants, and constants values (if any).
Example:
// Abstract Class with Properties
abstract class Animal {
public $name;
abstract public function makeSound();
}
// Interface with Constants (No Properties)
interface AnimalInterface {
const MAX_AGE = 100; // Constant
public function makeSound();
}
6. Visibility of Methods
Abstract Class:
- Methods can have different visibility levels:
public,protected, orprivate. - The visibility of abstract methods must be maintained when implemented in subclasses.
Interface:
- All methods declared in an interface must be public, because they need to be accessible by the classes that implement the interface.
7. Use Cases
Abstract Class:
- Shared functionality: When you have common code that should be shared across multiple classes, such as default behavior for certain methods.
- Common ancestor: When you want to ensure all derived classes share a common base and you can provide some default functionality.
Interface:
- Multiple behaviors: When different classes need to implement a set of methods but may have different implementations, and they don’t necessarily share any common ancestor.
- Decoupling code: When you need to decouple the definition of behavior from its implementation.
8. Constructor
Abstract Class:
- Abstract classes can have constructors and can define behavior that is shared across subclasses.
Interface:
- Interfaces cannot have constructors because they only define method signatures, not implementations.
9. Example of Abstract Class vs. Interface
Abstract Class Example:
// Abstract Class
abstract class Car {
public $model;
// Constructor
public function __construct($model) {
$this->model = $model;
}
// Concrete method
public function startEngine() {
echo "Engine started";
}
// Abstract method
abstract public function drive();
}
class Sedan extends Car {
public function drive() {
echo "Driving a sedan";
}
}
$sedan = new Sedan("Toyota");
$sedan->startEngine(); // Inherited method
$sedan->drive(); // Implemented method
Interface Example:
// Interface
interface Vehicle {
public function startEngine();
public function drive();
}
class Sedan implements Vehicle {
public function startEngine() {
echo "Engine started";
}
public function drive() {
echo "Driving a sedan";
}
}
$sedan = new Sedan();
$sedan->startEngine(); // Implemented method
$sedan->drive(); // Implemented method
Summary of Key Differences
| Feature | Abstract Class | Interface |
|---|---|---|
| Method Implementation | Can have both abstract and concrete methods | Can only have method signatures (PHP 8 allows default methods) |
| Properties | Can have properties with default values | Cannot have properties |
| Constructor | Can have constructors | Cannot have constructors |
| Inheritance | Single inheritance (one parent class) | Multiple inheritance (can implement multiple interfaces) |
| Visibility | Can have public, protected, or private methods | All methods must be public |
| Use Case | Use when there’s common functionality | Use when defining a contract (set of methods) |
| Access to Methods | Can be inherited or overridden | Must be implemented by the class |
Conclusion
Both abstract classes and interfaces are powerful tools in PHP’s object-oriented design, but they serve different purposes.
- Abstract classes are used when you want to share common functionality and state across classes.
- Interfaces are used to define a contract that multiple, potentially unrelated, classes must adhere to.
Choosing between an abstract class and an interface depends on the specific needs of your application’s architecture. If you need shared functionality, go with an abstract class. If you need to ensure that a set of methods is implemented across multiple classes, use an interface.
Top comments (0)