Difference Between abstract class and interface in PHP

In PHP, both abstract classes and interfaces are used to define structures for other classes to follow, but they serve different purposes and have distinct characteristics. Understanding when to use an abstract class versus an interface is crucial for designing a well-structured and flexible object-oriented system. Let’s explore the differences between these two concepts.

1. Definition

Abstract Class:

An abstract class is a class that cannot be instantiated on its own and is intended to be extended by other classes. It may contain both abstract methods (methods without implementations) and concrete methods (methods with implementations). Abstract classes allow you to define a common base class for a group of related classes, with some shared functionality and some methods that must be implemented by the derived classes.

Interface:

An interface is a contract that defines a set of methods that a class must implement, but unlike an abstract class, it cannot contain any method implementations (in PHP, prior to version 8, interfaces couldn’t have any implementation, though PHP 8 introduced default methods in interfaces). Interfaces focus purely on the structure (the methods that should exist) and leave the implementation to the class.

2. Purpose

• Abstract Class: Used when you have a base class that should provide default behavior or share some common functionality among subclasses but still allow subclasses to define some of their behavior.
• Interface: Used to define a set of methods that unrelated classes must implement. Interfaces are ideal for defining common behaviors across classes that do not share a common ancestor.

3. Method Implementation

Abstract Class:

• Can have both abstract methods (without implementation) and concrete methods (with implementation).
• Abstract methods must be implemented by any subclass, but concrete methods can be inherited as-is or overridden.

Interface:

• Can only declare method signatures (methods without bodies), leaving the implementation to the classes.
• PHP 8 allows interfaces to have default methods, which means you can provide an implementation, but the class can still override it.

Example:

// Abstract Class
abstract class Animal {
    abstract public function makeSound(); // Abstract method
    public function sleep() {
        echo "Sleeping..."; // Concrete method
    }
}

// Interface
interface AnimalInterface {
    public function makeSound(); // Only method signature
    public function eat(); // Only method signature
}

4. Inheritance vs. Implementation

Abstract Class:

• A class can extend only one abstract class because PHP does not support multiple inheritance.
• A subclass inherits both the abstract and concrete methods of the abstract class.

Interface:

• A class can implement multiple interfaces. This is PHP’s way of supporting multiple inheritance for behavior (though not for implementation).

Example:

// Abstract Class Example
abstract class Bird {
    abstract public function fly();
}

class Sparrow extends Bird {
    public function fly() {
        echo "Sparrow is flying";
    }
}

// Interface Example
interface Flyable {
    public function fly();
}

interface Eatable {
    public function eat();
}

class Sparrow implements Flyable, Eatable {
    public function fly() {
        echo "Sparrow is flying";
    }

    public function eat() {
        echo "Sparrow is eating";
    }
}

5. Properties

Abstract Class:

• An abstract class can have properties (variables) with default values. These properties can be inherited by child classes.

Interface:

• An interface cannot have properties. It can only define method signatures, constants, and constants values (if any).

Example:

// Abstract Class with Properties
abstract class Animal {
    public $name;
    abstract public function makeSound();
}

// Interface with Constants (No Properties)
interface AnimalInterface {
    const MAX_AGE = 100; // Constant
    public function makeSound();
}

6. Visibility of Methods

Abstract Class:

• Methods can have different visibility levels: public, protected, or private.
• The visibility of abstract methods must be maintained when implemented in subclasses.

Interface:

• All methods declared in an interface must be public, because they need to be accessible by the classes that implement the interface.

7. Use Cases

Abstract Class:

• Shared functionality: When you have common code that should be shared across multiple classes, such as default behavior for certain methods.
• Common ancestor: When you want to ensure all derived classes share a common base and you can provide some default functionality.

Interface:

• Multiple behaviors: When different classes need to implement a set of methods but may have different implementations, and they don’t necessarily share any common ancestor.
• Decoupling code: When you need to decouple the definition of behavior from its implementation.

8. Constructor

Abstract Class:

• Abstract classes can have constructors and can define behavior that is shared across subclasses.

Interface:

• Interfaces cannot have constructors because they only define method signatures, not implementations.

9. Example of Abstract Class vs. Interface

Abstract Class Example:

// Abstract Class
abstract class Animal {
    abstract public function makeSound(); // Abstract method
    public function sleep() {
        echo "Sleeping..."; // Concrete method
    }
}

// Interface
interface AnimalInterface {
    public function makeSound(); // Only method signature
    public function eat(); // Only method signature
}

Interface Example:

// Abstract Class Example
abstract class Bird {
    abstract public function fly();
}

class Sparrow extends Bird {
    public function fly() {
        echo "Sparrow is flying";
    }
}

// Interface Example
interface Flyable {
    public function fly();
}

interface Eatable {
    public function eat();
}

class Sparrow implements Flyable, Eatable {
    public function fly() {
        echo "Sparrow is flying";
    }

    public function eat() {
        echo "Sparrow is eating";
    }
}

Summary of Key Differences

Conclusion

Both abstract classes and interfaces are powerful tools in PHP’s object-oriented design, but they serve different purposes.

• Abstract classes are used when you want to share common functionality and state across classes.
• Interfaces are used to define a contract that multiple, potentially unrelated, classes must adhere to.

Choosing between an abstract class and an interface depends on the specific needs of your application’s architecture. If you need shared functionality, go with an abstract class. If you need to ensure that a set of methods is implemented across multiple classes, use an interface.

The above is the detailed content of Understanding the Difference Between `abstract class` and `interface` in PHP. For more information, please follow other related articles on the PHP Chinese website!