Why interfaces are needed in PHP - Why It Works This Way

Overview - Why interfaces are needed

What is it?

Interfaces in programming are like contracts that say what methods a class must have, without saying how they work. They let different classes promise to do certain things, so code can use them without knowing the details. This helps keep programs organized and flexible. Interfaces are especially useful when many different classes need to work together in a predictable way.

Why it matters

Without interfaces, programmers would struggle to make different parts of a program work together smoothly. Each class might do things differently, making it hard to swap parts or add new features without breaking the program. Interfaces solve this by setting clear rules everyone follows, making code easier to understand, maintain, and extend. This saves time and reduces bugs in real projects.

Where it fits

Before learning interfaces, you should understand classes and objects in PHP. After mastering interfaces, you can learn about traits, abstract classes, and design patterns like dependency injection that rely on interfaces for flexible code.

Mental Model

Core Idea

An interface is a promise that a class will have certain methods, letting different classes be used interchangeably without knowing their inner details.

Think of it like...

Think of an interface like a remote control standard for TVs. No matter the TV brand or model, if it follows the remote control standard, you can use the same remote to turn it on, change channels, or adjust volume. You don’t need to know how each TV works inside, just that it responds to the remote’s buttons.

┌───────────────┐        ┌───────────────┐        ┌───────────────┐
│   Interface   │───────▶│   Class A     │        │   Class B     │
│  (methods)    │        │ (implements)  │        │ (implements)  │
└───────────────┘        └───────────────┘        └───────────────┘
         ▲                      ▲                        ▲
         │                      │                        │
         └─────────Used by code that works with any class following the interface─────────┘

Build-Up - 7 Steps

1

Foundation

Understanding Classes and Methods

Concept: Learn what classes and methods are in PHP, the building blocks for interfaces.

In PHP, a class is like a blueprint for creating objects. Methods are actions these objects can perform. For example, a class Car might have methods like startEngine() and stopEngine(). Each class defines how these methods work.

Result

You can create objects from classes and call their methods to perform actions.

Knowing classes and methods is essential because interfaces define which methods classes must have, without their details.

2

Foundation

What is an Interface in PHP?

Concept: Introduce the interface keyword and its purpose to define method signatures without implementation.

An interface in PHP declares method names and their parameters but does not provide the code inside. Classes that implement the interface must write the code for these methods. For example: interface Logger { public function log(string $message); } This means any class implementing Logger must have a log() method.

Result

Interfaces set a rule that classes must follow, ensuring they have certain methods.

Understanding that interfaces only declare methods helps separate what a class must do from how it does it.

3

Intermediate

Why Use Interfaces Instead of Classes?

🤔Before reading on: do you think interfaces are just like abstract classes? Commit to your answer.

Concept: Explain the difference between interfaces and abstract classes and why interfaces are more flexible.

Abstract classes can have method code and properties, but a class can only extend one abstract class. Interfaces only declare methods and a class can implement many interfaces. This allows more flexible designs where a class can promise to do multiple things by implementing multiple interfaces.

Result

Interfaces enable multiple promises from one class, unlike single inheritance with abstract classes.

Knowing interfaces allow multiple implementations helps design flexible and reusable code.

4

Intermediate

Interfaces Enable Polymorphism

🤔Before reading on: do you think code using interfaces needs to know the class details? Commit to your answer.

Concept: Show how interfaces let code work with different classes through the same interface type.

When a function expects an interface type, it can accept any class implementing that interface. For example: function writeLog(Logger $logger) { $logger->log('Hello'); } This function can use any Logger implementation without caring how log() works inside.

Result

Code becomes more flexible and easier to extend by programming to interfaces, not classes.

Understanding polymorphism through interfaces unlocks powerful design patterns and easier maintenance.

5

Intermediate

Interfaces Help with Code Organization

Concept: Explain how interfaces separate what code does from how it does it, improving clarity.

By defining interfaces, teams can agree on method names and parameters before writing classes. This helps organize large projects by setting clear contracts. Developers can work independently on different classes as long as they follow the interface.

Result

Projects become easier to manage and less error-prone when interfaces define clear roles.

Knowing interfaces improve collaboration and reduce bugs by enforcing consistent method signatures.

6

Advanced

Interfaces in Dependency Injection

🤔Before reading on: do you think dependency injection works without interfaces? Commit to your answer.

Concept: Show how interfaces enable swapping implementations easily in dependency injection.

Dependency injection means giving objects their dependencies from outside. By depending on interfaces instead of concrete classes, you can swap implementations without changing the code that uses them. For example, a Mailer interface can have different classes for SMTP or API mail sending, and the system can switch between them easily.

Result

Code becomes more modular, testable, and adaptable to change.

Understanding interfaces in dependency injection reveals how to build flexible, maintainable systems.

7

Expert

Interface Segregation Principle in Practice

🤔Before reading on: do you think bigger interfaces are always better? Commit to your answer.

Concept: Introduce the principle that interfaces should be small and focused to avoid forcing classes to implement unused methods.

The Interface Segregation Principle says it's better to have many small interfaces than one big one. This avoids classes having to implement methods they don't need. For example, instead of one big Vehicle interface, have separate interfaces like Drivable and Floatable. Classes implement only what they actually do.

Result

Interfaces stay clean and classes remain simple, improving code quality and flexibility.

Knowing this principle helps avoid bloated interfaces and keeps code easier to maintain and extend.

Under the Hood

At runtime, PHP checks that a class implementing an interface has all the required methods with correct signatures. This check happens when the class is loaded, ensuring the contract is fulfilled. Interfaces themselves do not generate code for methods; they only define method signatures. When code uses an interface type, PHP treats any implementing class as valid, enabling polymorphism.

Why designed this way?

Interfaces were designed to provide a strict contract without implementation to allow multiple inheritance of method signatures, which PHP does not support with classes. This design avoids the complexity of multiple inheritance while enabling flexible code reuse and polymorphism. Alternatives like abstract classes were limited by single inheritance, so interfaces fill that gap.

┌───────────────┐
│   Interface   │
│ (method list) │
└──────┬────────┘
       │
       ▼
┌───────────────┐       ┌───────────────┐
│   Class A     │       │   Class B     │
│ (implements)  │       │ (implements)  │
│ method code   │       │ method code   │
└───────────────┘       └───────────────┘
       │                      │
       └─────────┬────────────┘
                 ▼
          ┌───────────────┐
          │  Client Code  │
          │ (uses interface)│
          └───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Do you think interfaces can contain method code? Commit to yes or no.

Common Belief: Interfaces can have method implementations like classes.

Reality: Interfaces only declare method signatures without any code. Classes implementing interfaces must provide the method code.

Why it matters: Thinking interfaces have code leads to confusion and errors when trying to put code inside interfaces, which PHP does not allow.

Quick: Can a class implement multiple interfaces? Commit to yes or no.

Common Belief: A class can only implement one interface, like it can only extend one class.

Reality: A class can implement many interfaces, allowing it to promise multiple sets of methods.

Why it matters: Believing otherwise limits design flexibility and prevents using interfaces to their full power.

Quick: Does implementing an interface guarantee the class works correctly? Commit to yes or no.

Common Belief: If a class implements an interface, it must work perfectly as expected.

Reality: Implementing an interface only guarantees method presence, not correct behavior. The class can still have bugs or wrong logic.

Why it matters: Assuming interface implementation means correctness can cause overlooked bugs and false confidence.

Quick: Are interfaces only useful for large projects? Commit to yes or no.

Common Belief: Interfaces are only needed in big, complex software.

Reality: Interfaces help organize code and improve flexibility even in small projects by defining clear contracts.

Why it matters: Ignoring interfaces in small projects can lead to messy code and harder maintenance as projects grow.

Expert Zone

1

Interfaces can be used to define event listeners or callbacks, enabling decoupled event-driven designs.

2

PHP 8 introduced union types in interfaces, allowing more precise method signatures and better type safety.

3

Interfaces can extend other interfaces, creating layered contracts that build on each other for complex designs.

When NOT to use

Interfaces are not suitable when you need to share code implementation between classes; abstract classes or traits are better for that. Also, avoid interfaces for very simple or one-off classes where the overhead of defining contracts is unnecessary.

Production Patterns

In real-world PHP applications, interfaces are heavily used in frameworks like Laravel and Symfony to define service contracts, enabling dependency injection and easy swapping of implementations for testing or different environments.

Connections

Dependency Injection

Interfaces enable dependency injection by allowing code to depend on abstractions rather than concrete classes.

Understanding interfaces clarifies how dependency injection achieves flexible and testable code by swapping implementations easily.

Design Patterns

Many design patterns like Strategy and Adapter rely on interfaces to define interchangeable behaviors.

Knowing interfaces helps grasp how design patterns promote reusable and maintainable code structures.

Contracts in Law

Interfaces are like legal contracts that specify obligations without detailing how to fulfill them.

Seeing interfaces as contracts helps understand their role in enforcing consistent behavior across different implementations.

Common Pitfalls

#1 Trying to put method code inside an interface.

Wrong approach:

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

Correct approach:

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

Root cause:

Misunderstanding that interfaces only declare method signatures, not implementations.

#2 Implementing an interface but forgetting to define all its methods.

Wrong approach:

class FileLogger implements Logger {
// Missing log() method
}

Correct approach:

class FileLogger implements Logger {
public function log(string $message) {
// method code here
}
}

Root cause:

Not realizing PHP requires all interface methods to be implemented in the class.

#3 Using concrete classes directly instead of interfaces in function parameters.

Wrong approach:

function writeLog(FileLogger $logger) {
$logger->log('Hi');
}

Correct approach:

function writeLog(Logger $logger) {
$logger->log('Hi');
}

Root cause:

Not understanding that depending on interfaces increases flexibility and testability.

Key Takeaways

Interfaces define a set of method signatures that classes must implement, acting as a contract.

They enable different classes to be used interchangeably, promoting flexible and maintainable code.

Interfaces allow multiple inheritance of method signatures, overcoming PHP's single class inheritance limit.

Programming to interfaces rather than concrete classes supports powerful design patterns and dependency injection.

Understanding interfaces helps write clearer, more organized, and scalable PHP applications.