Interface declaration and implementation in PHP - Deep Dive

Overview - Interface declaration and implementation

What is it?

An interface in PHP is a way to define a set of methods that a class must implement, without providing the method's code. It acts like a contract that ensures any class using the interface will have those methods. Interfaces help organize code and make sure different classes share common behaviors. They only declare method names and signatures, not how they work.

Why it matters

Interfaces exist to make code more organized and predictable. Without interfaces, it would be hard to guarantee that different classes have the same methods, making it difficult to use them interchangeably. This can cause bugs and confusion in bigger programs. Interfaces help teams work together by setting clear rules for how classes should behave.

Where it fits

Before learning interfaces, you should understand basic PHP classes and methods. 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, ensuring consistent behavior without dictating how those methods work.

Think of it like...

Think of an interface like a recipe card listing the dishes you must cook, but it doesn't tell you how to cook them. Each chef (class) can prepare the dishes their own way, but they must make all the dishes on the card.

┌───────────────┐
│   Interface   │
│───────────────│
│ + methodA()   │
│ + methodB()   │
└──────┬────────┘
       │ implements
┌──────▼────────┐
│    Class      │
│───────────────│
│ + methodA()   │
│ + methodB()   │
│ + extraMethod()│
└───────────────┘

Build-Up - 7 Steps

1

Foundation

What is an Interface in PHP

Concept: Introduce the basic idea of an interface as a method list without code.

In PHP, an interface is declared using the keyword 'interface'. It lists method names and their parameters but does not include any code inside the methods. For example: interface Talkable { public function talk(); } This means any class that uses Talkable must have a talk() method.

Result

You can declare interfaces that define method names without code.

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

2

Foundation

Implementing an Interface in a Class

Concept: Show how a class uses an interface and must define all its methods.

A class uses the 'implements' keyword to promise it will have all methods from the interface. For example: class Person implements Talkable { public function talk() { echo "Hello!"; } } If the class does not define talk(), PHP will give an error.

Result

Classes that implement interfaces must define all interface methods.

Knowing that PHP enforces method implementation prevents missing required methods and runtime errors.

3

Intermediate

Multiple Interfaces Implementation

🤔Before reading on: Do you think a class can implement more than one interface in PHP? Commit to your answer.

Concept: Explain that classes can implement multiple interfaces separated by commas.

PHP allows a class to implement many interfaces at once. For example: interface Movable { public function move(); } class Robot implements Talkable, Movable { public function talk() { echo "Beep boop"; } public function move() { echo "Moving forward"; } } This means Robot must have both talk() and move() methods.

Result

Classes can promise to follow multiple contracts at once.

Understanding multiple interfaces lets you design flexible classes that combine behaviors.

4

Intermediate

Interfaces with Method Signatures Only

🤔Before reading on: Can interfaces in PHP contain properties or method bodies? Commit to your answer.

Concept: Clarify that interfaces only declare method signatures, no properties or code.

Interfaces cannot have properties or method bodies. They only list method names, visibility (always public), and parameters. For example, this is invalid: interface Wrong { public $name; // Not allowed public function greet() { echo "Hi"; // Not allowed } } PHP will throw errors for this.

Result

Interfaces strictly define method signatures without implementation or properties.

Knowing this prevents confusion about what can be inside an interface and keeps contracts clean.

5

Intermediate

Type Hinting with Interfaces

Concept: Show how interfaces can be used to require certain types in function parameters.

You can use interfaces to type hint parameters, meaning the function accepts any object that implements the interface. For example: function makeTalk(Talkable $obj) { $obj->talk(); } This function can accept any object that implements Talkable, making code flexible and safe.

Result

Interfaces enable flexible and safe function parameters.

Understanding type hinting with interfaces helps write reusable and interchangeable code.

6

Advanced

Interface Inheritance and Extension

🤔Before reading on: Do you think interfaces can inherit from other interfaces in PHP? Commit to your answer.

Concept: Explain that interfaces can extend other interfaces to build bigger contracts.

Interfaces can extend one or more other interfaces, combining their method lists. For example: interface Walkable { public function walk(); } interface Talkable { public function talk(); } interface Personable extends Walkable, Talkable {} class Human implements Personable { public function walk() { echo "Walking"; } public function talk() { echo "Talking"; } } Human must implement all methods from Walkable and Talkable.

Result

Interfaces can build on each other to create complex contracts.

Knowing interface inheritance helps organize large codebases with layered behaviors.

7

Expert

Interfaces vs Abstract Classes in Practice

🤔Before reading on: Do you think interfaces and abstract classes in PHP serve the same purpose? Commit to your answer.

Concept: Compare interfaces and abstract classes to understand when to use each.

Both interfaces and abstract classes define methods that child classes must implement. But: - Interfaces only declare methods, no code or properties. - Abstract classes can have method code and properties. - A class can implement multiple interfaces but extend only one abstract class. Use interfaces to define pure contracts and abstract classes to share code. For example, an abstract class can provide common helper methods, while interfaces ensure consistent method names.

Result

Understanding the difference guides better design choices.

Knowing when to use interfaces or abstract classes prevents design mistakes and improves code flexibility.

Under the Hood

When PHP runs a class that implements an interface, it checks at compile time that all interface methods are present in the class. This ensures the class fulfills the contract. Interfaces themselves do not generate code for methods; they only define method signatures. At runtime, PHP treats interface methods like normal methods but enforces their presence strictly. This mechanism allows polymorphism, where code can use any object implementing the interface without knowing its exact class.

Why designed this way?

Interfaces were designed to separate the 'what' from the 'how' in object-oriented programming. This allows different classes to share a common set of behaviors without forcing them to share code or inheritance. It supports multiple inheritance of type, which PHP classes alone cannot do. This design promotes loose coupling and easier maintenance. Alternatives like abstract classes were limited because PHP only allows single inheritance, so interfaces fill that gap.

┌───────────────┐
│   Interface   │
│───────────────│
│ + methodA()   │
│ + methodB()   │
└──────┬────────┘
       │
       │ compile-time check
       ▼
┌───────────────┐
│    Class      │
│───────────────│
│ + methodA()   │
│ + methodB()   │
│ + otherMethod()│
└───────────────┘
       │
       │ runtime polymorphism
       ▼
┌───────────────┐
│  Client Code  │
│───────────────│
│ uses Interface│
│ methods       │
└───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Can interfaces contain properties in PHP? Commit to yes or no before reading on.

Common Belief: Interfaces can have properties just like classes.

Reality: Interfaces cannot have properties; they only declare method signatures.

Why it matters: Trying to add properties to interfaces causes errors and confusion about what interfaces are for.

Quick: Does implementing an interface automatically provide method code? Commit to yes or no before reading on.

Common Belief: When a class implements an interface, it inherits the method code from the interface.

Reality: Interfaces do not provide any method code; the class must write all method bodies.

Why it matters: Assuming interfaces provide code leads to missing method implementations and runtime errors.

Quick: Can a class implement multiple interfaces in PHP? Commit to yes or no before reading on.

Common Belief: A class can only implement one interface at a time.

Reality: A class can implement multiple interfaces separated by commas.

Why it matters: Believing only one interface is allowed limits design flexibility and code reuse.

Quick: Are interfaces and abstract classes interchangeable in PHP? Commit to yes or no before reading on.

Common Belief: Interfaces and abstract classes serve the same purpose and can be used interchangeably.

Reality: Interfaces only declare methods without code, while abstract classes can have code and properties; they serve different roles.

Why it matters: Confusing these leads to poor design choices and misuse of PHP features.

Expert Zone

1

Interfaces can be used as type hints to enable polymorphism without inheritance, allowing flexible and decoupled code.

2

Using interface segregation (small, focused interfaces) improves code maintainability and prevents forcing classes to implement unused methods.

3

PHP 8 introduced 'readonly' properties and union types, but interfaces still cannot declare properties, preserving their pure contract role.

When NOT to use

Avoid using interfaces when you need to share common code or properties; use abstract classes instead. Also, if your design requires state or partial implementations, interfaces alone are insufficient.

Production Patterns

In real-world PHP applications, interfaces are widely used for dependency injection, allowing swapping implementations easily for testing or different environments. Frameworks like Laravel rely heavily on interfaces to define service contracts, promoting modular and testable code.

Connections

Abstract Classes

Related concept with overlapping purpose but different capabilities

Understanding interfaces clarifies when to use abstract classes for shared code versus interfaces for pure contracts.

Dependency Injection

Interfaces enable dependency injection by defining contracts for services

Knowing interfaces helps grasp how dependency injection allows flexible swapping of implementations without changing client code.

Contracts in Law

Interfaces are like legal contracts specifying obligations without dictating methods

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

Common Pitfalls

#1 Forgetting to implement all interface methods

Wrong approach:

class Dog implements Talkable {
// Missing talk() method
}

Correct approach:

class Dog implements Talkable {
public function talk() {
echo "Woof!";
}
}

Root cause:

Misunderstanding that PHP requires all interface methods to be implemented, leading to fatal errors.

#2 Trying to add properties inside an interface

Wrong approach:

interface Animal {
public $name;
}

Correct approach:

interface Animal {
public function getName();
}

Root cause:

Confusing interfaces with classes and expecting them to hold data.

#3 Assuming interface methods have default code

Wrong approach:

interface Speaker {
public function speak() {
echo "Hello";
}
}

Correct approach:

interface Speaker {
public function speak();
}

Root cause:

Not knowing interfaces only declare method signatures, not implementations.

Key Takeaways

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

They do not contain any method code or properties, only method declarations.

Classes can implement multiple interfaces, allowing flexible combination of behaviors.

Interfaces enable polymorphism and type hinting, making code more modular and testable.

Understanding the difference between interfaces and abstract classes is key to good object-oriented design.