Inheritance are a very important part in PHP object-oriented programming (OOP). It allows a child class to acquire the properties and methods of a parent class. In this article, we will learn about Inheritance in PHP in detail with help of examples.
Inheritance is a fundamental concept in object-oriented programming (OOP), Which allows a child class or subclass to inherit the properties and methods of parent class or superclass. As like we can use property of our father like vehicle, mobile etc. Here, Father is parent class or superclass & we are child class or subclass.
What is Inheritance?
By using inheritance, you may make subclasses that take over methods and properties from their parent classes. The main objective of inheritance is to create a hierarchical relationship between classes and encourage code reuse.
When implementing inheritance in PHP, the "extends" keyword is used to specify which class is being extended.
For Example, Suppose the class Animal, which includes methods like eat() and fields like name. In addition to providing its unique characteristics, such as bark(), a class Dog can inherit from Animal and obtain access to these attributes and methods.
<?php
class Animal {
public $name;
public function __construct($name) {
$this->name = $name;
}
public function eat() {
echo "$this->name is eating.\n";
}
}
class Dog extends Animal {
public function bark() {
echo "$this->name is barking.\n";
}
}
?>
In this example, the Dog class inherits the eat() method from the Animal class and adds its unique method bark().
Method Overriding
By defining a method with the same name as its parent class, a child class can override that method. This is helpful when a method requires a specified implementation from the child class.
Example
<?php
class ParentClass {
public function Hello() {
echo "Hello from ParentClass.\n";
}
}
class ChildClass extends ParentClass {
public function Hello() {
echo "Hello from ChildClass.\n";
}
}
$child = new ChildClass();
$child->Hello();
?>
Output
Hello from ChildClass.
In above example, if we call ChildClass & use this method "Hello", it always show output from child class "Hello" method. In this case, If we want to call "Hello" method from parent class, we need a keyword "parent". This keyword is used to call method or constructor from parent class.
Example
<?php
class ParentClass {
public function Hello() {
echo "Hello from ParentClass.\n";
}
}
class ChildClass extends ParentClass {
public function Hello() {
parent::Hello(); // Calls the parent class method
echo "Hello from ChildClass.\n";
}
}
$child = new ChildClass();
$child->Hello();
?>
Output
Hello from ParentClass.
Hello from ChildClass.
Types of Inheritance
- Single inheritance
- Multi-level inheritance
- Hierarchical Inheritance
- Multiple Inheritance: PHP does not support multiple inheritance directly (a class cannot inherit from more than one class). However, traits can be used to achieve similar functionality.
Single inheritance
When a class inherits attributes and methods from only one parent class in PHP, this is known as single inheritance. When it comes to object-oriented programming, this is the most fundamental and widely utilized type of inheritance.
Example
<?php
// Parent class
class Vehicle {
public $brand;
public function __construct($brand) {
$this->brand = $brand;
}
public function drive() {
echo $this->brand . " is driving.\n";
}
}
// Child class
class Car extends Vehicle {
public $model;
public function __construct($brand, $model) {
parent::__construct($brand); // Call the parent class constructor
$this->model = $model;
}
public function displayDetails() {
echo "Brand: " . $this->brand . ", Model: " . $this->model . "\n";
}
}
// Create an object of the child class
$car = new Car("Toyota", "Corolla");
$car->drive(); // Inherited method
$car->displayDetails(); // Method from the child class
?>
Output
Toyota is driving.
Brand: Toyota, Model: Corolla
Explanation
- Parent Class (Vehicle)
- Contains properties like $brand and a method drive().
- Child Class (Car)
- Inherits the properties and methods of the Vehicle class.
- Adds a new property ($model) and method (displayDetails()).
- Uses parent::__construct() to call the parent class constructor.
Single Inheritance Limitation
A child class (Car) can extend only one parent class (Vehicle) in PHP. For Example, class Car extends Vehicle – only one parent class can be specified.
Benefits
- Reusability: You can reuse the logic from the parent class.
- Extensibility: The child class can add its own functionality.
If you need functionality from multiple parent classes, PHP uses Traits, but that is not part of single inheritance.
Also read Access Modifiers in PHP
Multi-level inheritance
When a class inherits from a parent class in PHP, a chain of inheritance is created when another class inherits from that child class. Each level has the ability to modify or expand upon the previous class's methods and properties.
Example
<?php
// Base class (Parent class)
class Animal {
public $name;
public function __construct($name) {
$this->name = $name;
}
public function eat() {
echo $this->name . " is eating.\n";
}
}
// Intermediate class (Child of Animal)
class Mammal extends Animal {
public function walk() {
echo $this->name . " is walking.\n";
}
}
// Final class (Child of Mammal)
class Dog extends Mammal {
public function bark() {
echo $this->name . " is barking.\n";
}
}
// Create an object of the final class
$dog = new Dog("Buddy");
$dog->eat(); // Method from the Animal class
$dog->walk(); // Method from the Mammal class
$dog->bark(); // Method from the Dog class
?>
Output
Buddy is eating.
Buddy is walking.
Buddy is barking.
Explanation
- Base Class (Animal)
- Contains the $name property and the eat() method.
- Intermediate Class (Mammal)
- Inherits the Animal class.
- Adds the walk() method.
- Final Class (Dog)
- Inherits the Mammal class.
- Adds the bark() method.
- Object Instantiation
- An object of the Dog class has access to methods from all levels of inheritance: Animal, Mammal, and Dog.
Hierarchical Inheritance
When several child classes in PHP inherit from a single parent class, this happens. In addition to defining its own special features, each child class is free to utilize the parent class's methods and properties.
Example
<?php
// Parent class
class Animal {
public $name;
public function __construct($name) {
$this->name = $name;
}
public function eat() {
echo $this->name . " is eating.\n";
}
}
// Child class 1
class Dog extends Animal {
public function bark() {
echo $this->name . " is barking.\n";
}
}
// Child class 2
class Cat extends Animal {
public function meow() {
echo $this->name . " is meowing.\n";
}
}
// Child class 3
class Cow extends Animal {
public function moo() {
echo $this->name . " is mooing.\n";
}
}
// Create objects of each child class
$dog = new Dog("Buddy");
$dog->eat(); // Inherited from Animal
$dog->bark(); // Specific to Dog
$cat = new Cat("Whiskers");
$cat->eat(); // Inherited from Animal
$cat->meow(); // Specific to Cat
$cow = new Cow("Daisy");
$cow->eat(); // Inherited from Animal
$cow->moo(); // Specific to Cow
?>
Output
Buddy is eating.
Buddy is barking.
Whiskers is eating.
Whiskers is meowing.
Daisy is eating.
Daisy is mooing.
Explanation
- Parent Class (Animal)
- Contains common properties (e.g., $name) and methods (e.g., eat()).
- Child Classes (Dog, Cat, Cow)
- Each child class inherits the properties and methods of the Animal class.
- Each adds its own specific behavior:
- Dog has the bark() method.
- Cat has the meow() method.
- Cow has the moo() method.
Reusability
- Common functionality (eat()) is defined in the parent class and reused by all child classes.
- Child classes only define functionality specific to themselves.
Key Points
- Single Parent, Multiple Children
- In hierarchical inheritance, multiple child classes derive from the same parent class.
- Shared Functionality
- All child classes inherit the methods and properties of the parent class.
- Each child class can add its own unique methods or override parent methods.
- Use Case
- Hierarchical inheritance is useful when you have a base class with shared functionality, and you want multiple specialized classes to extend that functionality in their own way.
Conclusion
A strong component of PHP, inheritance improves code reuse, eliminates redundancy, and clearly defines relationships between classes. Developers may create better organized, maintainable, and scalable applications by comprehending and using inheritance well. But in order to get the best results, inheritance must be used carefully and in conjunction with other OOP concepts like composition and polymorphism.
