Defining an Abstract in PHP

In PHP, an abstract class can have both abstract methods (methods without a body) and properties (variables). The purpose of an abstract class is to provide a common base for other classes to inherit from, enforcing a structure while allowing customization through concrete implementations.

Key Points about Abstract Classes with Methods and Properties:

Abstract Methods: These are methods declared in the abstract class without a body. The child classes must implement these methods.

Concrete Methods: These are methods with implementations in the abstract class that can be inherited as-is by child classes.

Properties: Abstract classes can have properties just like regular classes. These properties can be public, protected, or private.

Example of an Abstract Class with Methods and Properties:

<?php
// Abstract class
abstract class Animal {
    // Property (can be inherited by child classes)
    protected $name;
    
    // Constructor to initialize the name property
    public function __construct($name) {
        $this->name = $name;
    }

    // Abstract method (must be implemented by any child class)
    abstract public function makeSound();

    // Concrete method (can be inherited as-is)
    public function getName() {
        return $this->name;
    }
}

// Dog class that extends Animal
class Dog extends Animal {
    // Implementing the abstract method
    public function makeSound() {
        echo "Bark! ";
    }
}

// Cat class that extends Animal
class Cat extends Animal {
    // Implementing the abstract method
    public function makeSound() {
        echo "Meow! ";
    }
}

// Instantiate objects of Dog and Cat
$dog = new Dog("Buddy");
$cat = new Cat("Whiskers");

echo $dog->getName() . " says: ";
$dog->makeSound(); // Outputs: Buddy says: Bark!

echo "
";

echo $cat->getName() . " says: ";
$cat->makeSound(); // Outputs: Whiskers says: Meow!
?>

Key Points:

An abstract class can have properties and methods like a regular class.

Abstract methods must be implemented in child classes, while concrete methods are inherited as-is.

Abstract classes provide a common template for all child classes while allowing flexibility in the child class implementations.

In above expamle, This structure ensures that all subclasses share common functionality (like the getName() method) but can implement their own unique behavior (like makeSound()).

Real-Life Example: Vehicle Management System

Imagine you're building a system to manage different types of vehicles (cars, trucks, motorcycles). All vehicles have certain common characteristics, such as being able to start, stop, and have a fuel type. However, different types of vehicles may have different implementations for how they start and stop.

Real-World Concept:

Abstract Class (Vehicle): This is a base class with properties like fuelType and methods like start() and stop(). The start() and stop() methods are abstract because the way a car starts is different from how a truck starts, so these methods will be implemented in the child classes.

Concrete Classes (Car, Truck, Motorcycle): These classes will implement the start() and stop() methods differently based on their own logic.

<?php
// Abstract class Vehicle
abstract class Vehicle {
    // Property to hold fuel type
    protected $fuelType;

    // Constructor to initialize the fuel type
    public function __construct($fuelType) {
        $this->fuelType = $fuelType;
    }

    // Abstract method start, must be implemented by subclasses
    abstract public function start();

    // Abstract method stop, must be implemented by subclasses
    abstract public function stop();

    // Concrete method to get fuel type
    public function getFuelType() {
        return $this->fuelType;
    }
}

// Concrete class Car that extends Vehicle
class Car extends Vehicle {
    // Implementing the start method for Car
    public function start() {
        echo "The car starts with an ignition key.
";
    }

    // Implementing the stop method for Car
    public function stop() {
        echo "The car stops by pressing the brake pedal.
";
    }
}

// Concrete class Truck that extends Vehicle
class Truck extends Vehicle {
    // Implementing the start method for Truck
    public function start() {
        echo "The truck starts with a large engine ignition.
";
    }

    // Implementing the stop method for Truck
    public function stop() {
        echo "The truck stops with heavy-duty brakes.
";
    }
}

// Concrete class Motorcycle that extends Vehicle
class Motorcycle extends Vehicle {
    // Implementing the start method for Motorcycle
    public function start() {
        echo "The motorcycle starts with a kickstart or button.
";
    }

    // Implementing the stop method for Motorcycle
    public function stop() {
        echo "The motorcycle stops by pressing the brake lever.
";
    }
}

// Create objects of different vehicles
$car = new Car("Gasoline");
$truck = new Truck("Diesel");
$motorcycle = new Motorcycle("Petrol");

echo "Car Fuel Type: " . $car->getFuelType() . "
";
$car->start();  // Outputs: The car starts with an ignition key.
$car->stop();   // Outputs: The car stops by pressing the brake pedal.

echo "
";

echo "Truck Fuel Type: " . $truck->getFuelType() . "
";
$truck->start(); // Outputs: The truck starts with a large engine ignition.
$truck->stop();  // Outputs: The truck stops with heavy-duty brakes.

echo "
";

echo "Motorcycle Fuel Type: " . $motorcycle->getFuelType() . "
";
$motorcycle->start(); // Outputs: The motorcycle starts with a kickstart or button.
$motorcycle->stop();  // Outputs: The motorcycle stops by pressing the brake lever.
?>