In PHP, the difference between interfaces and abstract classes is mainly reflected in the definition, inheritance model and implementation method. 1. The interface only defines method signatures (PHP 8.1 supports default methods), emphasizing "what should be done", while abstract classes can contain abstract methods and concrete implementations, emphasizing "how to implement some functions". 2. Classes can implement multiple interfaces, but can only inherit one abstract class, so interfaces are more flexible when combining multiple behaviors. 3. The interface method is exposed by default and cannot have attributes. Abstract classes support arbitrary access control, attributes, constructors and destructors. 4. Use interfaces when a unified API is required or when an interchangeable component is designed; abstract classes are used when a shared state or logically related classes are used. The selection basis is: the interface is used to define contracts, and the abstract class is used to share implementation logic.

In PHP, interfaces and abstract classes are both used to achieve abstraction and define contracts for classes, but they serve different purposes and have distinct characteristics. Understanding the differences between them is important for designing flexible and maintainable object-oriented code.

1. Definition and Purpose

An interface defines a contract that implementing classes must follow. It specifies a set of method signatures (and from PHP 8.1, also constants and default implementations via default methods), but does not include any implementation details.

An abstract class , on the other hand, can provide partial implementation. It's meant to be a base class for inheritance, and it can contain both abstract methods (with implementation) and concrete methods (with implementation).

• Interfaces focus on what a class should do.
• Abstract classes focus on how some part of that behavior can be done.

2. Inheritance Model

One key difference lies in how PHP handles inheritance with each:

• A class can implement multiple interfaces . This allows combining behaviors from different sources.

   class MyService implements Loggable, Cacheable {
      // ...
  }

• But a class can extend only one abstract class . PHP doesn't support multiple inheritance for classes.

   class MyBase extends ParentClass { 
      // Can't extend another class at the same time
  }

This makes interfaces more flexible when you need to design systems where objects may exhibit several unrelated behaviors.

3. Method and Property Implementation

When comparing what each can contain:

• Interfaces :

  • All methods must be public.
  • Cannot contain method bodies (unless using default methods in PHP 8.1).
  • Cannot have properties (but can define constants).
  • From PHP 8.1, you can use default methods with implementations.

• Abstract Classes :

  • Can have abstract and non-abstract methods.
  • Methods can have any visibility: public, protected, or private.
  • Can define and use properties.
  • Can include constructors and destructors.

So if you need shared state (like properties) or want to share implementation logic across subclasses, abstract classes are the way to go.

4. When to Use Which

Choosing between an interface and an abstract class depends on your design goals:

• Use an interface when:

  • You want to define a common API that different classes can implement.
  • You expect unrelated classes to need the same behavior.
  • You're designing plugins or services that should be interchangeable.

• Use an abstract class when:

  • You have closely related classes that share some logic.
  • You want to provide a common base with partially implemented functionality.
  • You need to encapsulate shared state (properties) and behavior.

For example, if you're building a payment system and want to enforce a processPayment() method across different gateways, an interface would work well. But if you're creating a base DatabaseModel class with some shared database interaction logic, an abstract class makes more sense.

Basically that's it. Knowing whether to use an interface or an abstract class comes down to whether you're defining a contract (interface) or sharing implementation logic (abstract class). Both are powerful tools, but they fit different roles in object-oriented design.

The above is the detailed content of What are the differences between Interfaces and Abstract Classes in PHP?. For more information, please follow other related articles on the PHP Chinese website!