An abstract method in PHP is a method that is declared but not defined in an abstract class. The purpose of an abstract method is to ensure that any subclass that extends the abstract class must provide an implementation for that method. Abstract methods are a key feature of object-oriented programming, used to define a consistent interface for all subclasses while allowing each subclass to provide its specific implementation.

Characteristics of Abstract Methods

1. Declaration Without Definition: Abstract methods are declared without any implementation (i.e., they have no body). They are intended to be implemented by child classes.
2. Only in Abstract Classes: Abstract methods can only be declared within an abstract class. You cannot have an abstract method in a non-abstract class.
3. Must Be Overridden: Any class that extends an abstract class must provide concrete implementations for all the abstract methods of the abstract class.

Syntax for Declaring an Abstract Method

An abstract method is declared using the abstract keyword followed by the method signature, without providing a method body.

abstract class AbstractClass {
    abstract public function abstractMethod();
}

Example of Abstract Method

Consider a scenario where you have different types of animals, and each animal has a different sound. You can define an abstract class Animal with an abstract method makeSound() to enforce each subclass to provide its specific implementation of how the animal makes sound.

abstract class Animal {
    // Abstract method - must be implemented by subclasses
    abstract public function makeSound();

    // Concrete method - can be inherited by subclasses
    public function eat() {
        echo "This animal is eating.\n";
    }
}

class Dog extends Animal {
    // Providing implementation for the abstract method
    public function makeSound() {
        echo "Woof! Woof!\n";
    }
}

class Cat extends Animal {
    // Providing implementation for the abstract method
    public function makeSound() {
        echo "Meow! Meow!\n";
    }
}

// Instantiate objects of Dog and Cat
$dog = new Dog();
$dog->makeSound(); // Outputs: Woof! Woof!
$dog->eat();       // Outputs: This animal is eating.

$cat = new Cat();
$cat->makeSound(); // Outputs: Meow! Meow!
$cat->eat();       // Outputs: This animal is eating.

Explanation

1. Abstract Class (Animal):

   • The Animal class is declared as abstract.
   • It contains an abstract method makeSound(). This method does not have a body and must be implemented by any subclass.

2. Child Classes (Dog and Cat):

   • Both Dog and Cat classes extend the Animal class.
   • Since the Animal class has an abstract method (makeSound()), both Dog and Cat classes must provide their own implementation of makeSound().
   • Each subclass implements the makeSound() method in a way that is specific to that animal.

3. Concrete Methods:

   • The eat() method is a concrete method defined in the Animal class, meaning it has a body and can be used directly by any subclass without modification.

Rules of Abstract Methods

1. Must Be in an Abstract Class: Abstract methods can only exist within an abstract class. This means you must mark a class as abstract to include any abstract methods.

   abstract class Vehicle {
       abstract public function startEngine();
   }
   

2. Cannot Have a Body: Abstract methods are declared without any implementation (i.e., they do not have a method body). They are intended to enforce that subclasses provide a specific implementation.

3. Child Classes Must Implement Abstract Methods: Any concrete (non-abstract) class that extends an abstract class must implement all abstract methods declared by the abstract class, or it will result in an error.

   class Car extends Vehicle {
       public function startEngine() {
           echo "Car engine started.\n";
       }
   }
   

4. Visibility: Abstract methods can be public, protected, or private. The child class must maintain the same visibility level or make it less restrictive, but not more restrictive.

   abstract class Machine {
       abstract protected function operate();
   }
   
   class WashingMachine extends Machine {
       // The visibility must be protected or more public (i.e., public)
       protected function operate() {
           echo "Washing machine is operating.\n";
       }
   }
   

Practical Use Cases

1. Define a Common Interface for Subclasses: Abstract methods are used when you want to ensure that all subclasses of an abstract class implement certain functionalities, but the actual implementation is left to each subclass.

   For example, if you have a PaymentGateway class, each payment provider (PayPal, Stripe, etc.) would implement the processPayment() method in their own way:

   abstract class PaymentGateway {
       abstract public function processPayment($amount);
   }
   
   class PayPal extends PaymentGateway {
       public function processPayment($amount) {
           echo "Processing payment of $amount via PayPal.\n";
       }
   }
   
   class Stripe extends PaymentGateway {
       public function processPayment($amount) {
           echo "Processing payment of $amount via Stripe.\n";
       }
   }
   

2. Template Design Pattern: Abstract methods are also commonly used in template method patterns, where the abstract class defines the skeleton of an algorithm but allows subclasses to provide specific implementations.

Summary

• Abstract Methods are methods that are declared but not implemented in an abstract class.
• They serve as a contract that child classes must fulfill.
• Abstract methods can only exist in abstract classes and must be implemented by any non-abstract subclass.
• This allows developers to define a consistent interface for all derived classes, while still leaving the implementation details to those subclasses.

Abstract methods are an important part of PHP's object-oriented programming, as they provide a mechanism to enforce structure and ensure that specific methods are implemented across all subclasses.