Talk about the use of interface in PHP

Indeed, the PHP interface has its purpose.

They are contracts, instruction manuals for other developers. However, it is still difficult to understand what the interface is used for.

Basic

Interface is an abstract class that cannot be directly instantiated, but can be implemented.

This is a basic example

interface MyInterface {
    public function setName(string $name);
    public function getName();
}

class MyClass implements MyInterface {
    private $name; 

    public function setName(string $name) { 
        $this->name = $name; 
    }

    public function getName() {
        return $this->name; 
    }
}

MyClass must implement the setName() and getName() methods. If you don't do this, you'll get a fatal error.

Fatal error: Class MyClass contains 2 abstract methods and must therefore be declared abstract or implement the remaining methods (MyInterface::setName, MyInterface::getName)

In addition, the methods defined in the interface Accessibility must be public, and class members cannot be defined in the interface.

Cause

Developers use interfaces to describe the common behavior of a class or a group of classes.

But why is it only responsible for encapsulating the implementation and not responsible for handling the details of each class?

For decoupling!

The interface allows you to change the implementation without changing the details, that is, how you use this implementation.

More advanced examples

Any caching system requires the following capabilities

• Store/setup in cache Content
• Get the content in the cache
• Delete the content in the cache

Based on this, we can create the following cache interface

interface CacheInterface {
    public function set(string $key, $val);
    public function get(string $key);
    public function delete(string $key);
}

to In this way, developers can know that they need to implement the cache interface. We don't need to know how to implement it. The result is that we can easily switch the cache system without changing the way it is used

Therefore, it is easy to change the cache system without changing the way the cache system is used in the project.

Symfony Example

Let’s look at the specific application of the example just now. For Symfony, if you want to implement any caching system, the best practice is to do it as follows

use Symfony\Contracts\Cache\CacheInterface;

class MyClass {
    private $cache;
    public function __construct(CacheInterface $cache)
    {
        $this->cache = $cache;
    }
}

Inject the cache interface into our class through dependency injection. Next time we modify the cache system, the MyClass class does not need to make any changes.

Multiple implementations VS multiple inheritance

PHP does not support multiple inheritance, the following method is impossible

class MyClass extends ClassX, ClassY {}

Part of the reason why this is not allowed is due to the Diamond issue.

However, you can do it

class ClassY extends ClassX {}
class MyClass extends ClassY {}

but ClassX and ClassY may be handled Different things, so using inheritance doesn't make any sense.

If you want to perform multiple behaviors, then you can have multiple interfaces

class MyClass implements InterfaceX, InterfaceY {}

In other words, you can let some classes share part of the functionality instead of sharing a parent class.

Summary

PHP interface is the method template of a class, which is very helpful for decoupled implementation and use.

This feature is especially useful when you need to maintain flexibility and ensure that all developers are following a set of rules.

[Related tutorial recommendations: "PHP Tutorial"]

The above is the detailed content of Talk about the use of interface in PHP. For more information, please follow other related articles on the PHP Chinese website!