**Course Title:** Modern PHP Development: Best Practices and Advanced Techniques **Section Title:** Object-Oriented Programming (OOP) in PHP **Topic:** Inheritance, Encapsulation, and Polymorphism **Overview** In this topic, we'll explore three fundamental concepts in Object-Oriented Programming (OOP): inheritance, encapsulation, and polymorphism. You'll learn how these concepts allow you to create more robust, flexible, and maintainable code. By the end of this topic, you'll be able to apply these concepts to your PHP development projects. **Inheritance** Inheritance is a mechanism that allows one class to inherit the properties and methods of another class. The child class inherits all the members (methods and properties) of the parent class and can also add new members or override the ones inherited from the parent class. **Key Benefits of Inheritance:** * Code reusability: Inheritance allows you to reuse the code of the parent class, reducing the amount of code you need to write and maintain. * Improved code organization: Inheritance helps you organize your code in a more logical and structured way. **Example: Inheritance in PHP** ```php // Define a parent class called "Vehicle" class Vehicle { protected $color; protected $speed; public function __construct($color, $speed) { $this->color = $color; $this->speed = $speed; } public function displayDetails() { echo "The $this->color vehicle has a speed of $this->speed km/h."; } } // Define a child class called "Car" that inherits from "Vehicle" class Car extends Vehicle { private $numberOfDoors; public function __construct($color, $speed, $numberOfDoors) { parent::__construct($color, $speed); $this->numberOfDoors = $numberOfDoors; } public function displayDetails() { parent::displayDetails(); echo " It has $this->numberOfDoors doors."; } } // Create an instance of the "Car" class $myCar = new Car("Red", 200, 4); $myCar->displayDetails(); // Output: The Red vehicle has a speed of 200 km/h. It has 4 doors. ``` **Encapsulation** Encapsulation is the concept of hiding the implementation details of an object from the outside world and only exposing the necessary information through public methods. **Key Benefits of Encapsulation:** * Improved code security: Encapsulation helps you protect your data from unauthorized access and modifications. * Reduced coupling: Encapsulation promotes loose coupling between objects, making your code more modular and maintainable. **Example: Encapsulation in PHP** ```php // Define a class called "BankAccount" that encapsulates the account balance class BankAccount { private $balance; public function deposit($amount) { if ($amount > 0) { $this->balance += $amount; } } public function getBalance() { return $this->balance; } public function withdraw($amount) { if ($amount > 0 && $this->balance >= $amount) { $this->balance -= $amount; } } } // Create an instance of the "BankAccount" class $myAccount = new BankAccount(); $myAccount->deposit(1000); echo $myAccount->getBalance(); // Output: 1000 $myAccount->withdraw(500); echo $myAccount->getBalance(); // Output: 500 ``` **Polymorphism** Polymorphism is the ability of an object to take on multiple forms, depending on the context in which it is used. **Key Benefits of Polymorphism:** * Improved code flexibility: Polymorphism allows you to write more generic code that can work with different types of objects. * Enhanced code reusability: Polymorphism promotes code reusability by allowing you to write code that can be used with different classes. **Example: Polymorphism in PHP** ```php // Define a parent class called "Shape" class Shape { public function calculateArea() {} } // Define child classes that inherit from "Shape" and override the "calculateArea" method class Circle extends Shape { private $radius; public function __construct($radius) { $this->radius = $radius; } public function calculateArea() { return 3.14 * pow($this->radius, 2); } } class Rectangle extends Shape { private $width; private $height; public function __construct($width, $height) { $this->width = $width; $this->height = $height; } public function calculateArea() { return $this->width * $this->height; } } // Create instances of the "Circle" and "Rectangle" classes $circle = new Circle(5); $rectangle = new Rectangle(4, 5); // Use polymorphism to calculate the area of the shapes function calculateShapeArea(Shape $shape) { echo $shape->calculateArea() . "\n"; } calculateShapeArea($circle); // Output: 78.5 calculateShapeArea($rectangle); // Output: 20 ``` **Conclusion** In this topic, you learned about inheritance, encapsulation, and polymorphism in PHP. These concepts are essential for creating robust, flexible, and maintainable code. By applying these concepts, you can write more efficient and effective code that meets the demands of modern PHP development. **What's Next?** In the next topic, we'll explore the concept of magic methods in PHP, including the `__construct`, `__get`, `__set`, and other methods that allow you to modify the behavior of your objects. You'll learn how to use these methods to improve the functionality and flexibility of your code. **We'd Love to Hear from You!** * Do you have any questions about inheritance, encapsulation, or polymorphism in PHP? * How do you use these concepts in your own PHP projects? * Share your thoughts and experiences with us by leaving a comment below. Read more about Inheritance, Encapsulation and Polymorphism in PHP at [PHP.net](https://www.php.net/manual/en/language.oop5.php)