> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# PHP Interface
An interface in PHP is an object-oriented programming construct that defines a strict contract specifying which methods a class must implement, without defining how those methods are implemented. It acts as a purely structural blueprint, enforcing method signatures and polymorphism across disparate classes.
## Syntax and Declaration
Interfaces are declared using the `interface` keyword. Classes adhere to an interface using the `implements` keyword.
```php theme={"dark"}
interface LoggerInterface {
public function log(string $message): void;
}
class FileLogger implements LoggerInterface {
public function log(string $message): void {
file_put_contents('app.log', $message);
}
}
```
## Technical Rules and Constraints
1. **Method Visibility:** All methods declared within an interface must have `public` visibility.
2. **No Implementation:** Methods inside an interface cannot contain a body. They consist solely of the method signature.
3. **No Instantiation:** Interfaces cannot be instantiated directly. Attempting to call `new LoggerInterface()` will result in a fatal error.
4. **Properties:** Interfaces cannot declare class properties (variables).
5. **Constants:** Interfaces can declare constants. Implementing classes inherit these constants, and prior to PHP 8.1, they could not be overridden.
6. **Signature Compatibility:** The implementing class must adhere to the interface's method signatures, subject to PHP's variance rules:
* **Covariance:** The implementing method's return type can be more specific (narrower) than the interface's return type.
* **Contravariance:** The implementing method's parameter types can be less specific (wider) than the interface's parameter types.
* **Parameter Extension:** The implementing class may add extra parameters to the method signature, provided that all additional parameters have default values (making them optional).
## Multiple Implementations
Unlike class inheritance (where a PHP class can only extend one parent class), a single class can implement multiple interfaces. The interface names are separated by commas.
```php theme={"dark"}
interface FormatterInterface {
public function format(array $data): string;
}
class DataHandler implements LoggerInterface, FormatterInterface {
public function log(string $message): void {
// Implementation required
}
public function format(array $data): string {
// Implementation required
return json_encode($data);
}
}
```
## Interface Inheritance
Interfaces can extend other interfaces using the `extends` keyword. An interface can extend multiple interfaces simultaneously, combining their method requirements.
```php theme={"dark"}
interface ReadableInterface {
public function read(): string;
}
interface WritableInterface {
public function write(string $data): bool;
}
interface FileSystemInterface extends ReadableInterface, WritableInterface {
public function getPermissions(): int;
}
```
If a class implements `FileSystemInterface`, it is strictly required to provide concrete implementations for `read()`, `write()`, and `getPermissions()`.
## Type Hinting
Interfaces are heavily utilized in PHP's type system. You can type-hint an interface in function or method parameters to accept any object whose class implements that interface, regardless of the object's specific class hierarchy.
```php theme={"dark"}
function processLog(LoggerInterface $logger, string $message): void {
$logger->log($message);
}
```
Tired of Poor PHP Skills? Fix That With Deep Grasping!
Learn More
