In this series, I will cover the fundamentals of PHP Object-Oriented Programming (OOP). The content will be organized into sequential parts, each focusing on a specific topic. If you're a beginner or unfamiliar with OOP concepts, this series is designed to guide you step by step. In this part, I will discuss about the access modifiers, encapsulation, and inheritance in PHP. Let's begin the journey of learning PHP OOP together!
What is Access Modifiers in PHP?
Access modifiers are used to control the access levels of class properties and methods. That is, it controls how much access you have, etc. PHP provides three types of access modifiers:
- public: Accessible from anywhere.
- protected: Accessible only within the class and its subclasses.
- private: Accessible only within the class.
To use these access modifiers, you need to declare them using the keywords public, protected, or private before defining the properties or methods. It is important to note that if you do not specify any access modifier for a property or method, it is considered public by default.
Code Example
class MyClass {
public $publicVar; // Accessible from anywhere
protected $protectedVar; // Accessible from this class and subclass
private $privateVar; // Accessible from only this class
public function publicMethod() {
// Accessible from anywhere
}
protected function protectedMethod() {
// Accessible from this class and subclass
}
private function privateMethod() {
// Accessible from only this class
}
}
Using these access modifiers, we can control the access to a class's data and functionality, which is closely related to encapsulation and security within a class.
What is Encapsulation?
Encapsulation is the process of creating a new entity to ensure privacy or information security. A class can have various properties and methods, and we can use access modifiers to define how these properties and methods can be accessed outside the class. Simply put, encapsulation is about controlling access to class data and functionality.
Encapsulation can occur at different levels:
Property-Level Encapsulation
Properties are data members of a class that are associated with the class’s object. By default, properties are public, but we can secure them using private or protected access modifiers. This prevents direct access to the data from external code. This concept is known as Property-Level Encapsulation.
Method-Level Encapsulation
Methods are the functions or operations of a class that work on its instances. A method may contain many implementations that can be hidden from external classes. By doing this, we allow external code to use the method but not access its internal implementation. This is known as Method-Level Encapsulation.
Class-Level Encapsulation
At this level, the properties and methods of a class are securely stored within the class, and direct access to them from outside the class is restricted. They can, however, be accessed through inheritance. This is referred to as Class-Level Encapsulation.
Apart from these, encapsulation can be implemented at other levels as needed.
What is Inheritance?
Inheritance is a programming concept where a class (called a subclass or child class) inherits the properties and methods from another class (called a superclass or parent class).
To simplify, consider a class with certain properties and methods. If another class requires these same properties and methods, instead of rewriting them, in that time we can inherit them from the original class into the new class. This concept is referred to as inheritance, and its primary purpose is to reuse code and avoid code duplication. When a class inherits from another class:
- The inheriting class is called the subclass or child class.
- The inherited class is called the superclass or parent class.
Let’s look at an example of code
Code Example
class Vehicle
{
public $name;
public $color;
public function start()
{
// start login
}
public function stop()
{
// stop login
}
}
class Car extends Vehicle
{
function __construct(string $name, string $color)
{
$this->name = $name;
$this->color = $color;
}
public function carInfo()
{
echo "Car name: $this->name\n";
echo "Car color: $this->color\n";
}
}
class Bus extends Vehicle
{
function __construct(string $name, string $color)
{
$this->name = $name;
$this->color = $color;
}
public function busInfo()
{
echo "Bus name: $this->name\n";
echo "Bus color: $this->color\n";
}
}
$toyota = new Car('Toyota', 'Red');
$toyota->start();
$toyota->carInfo();
$toyota->stop();
$tesla = new Bus('Zip', 'Blue');
$tesla->start();
$tesla->busInfo();
$tesla->stop();
In the above example, we can see that the Vehicle class is inherited by both the Car and Bus classes. As a result, the properties and methods of the Vehicle class that are marked as public or protected can be accessed within these subclasses.
What is Multi-level Inheritance?
Multi-level Inheritance refers to a scenario where a class inherits from another class, and then that class itself is inherited by a third class. This allows the third class to access the properties and methods (marked as public or protected) of both the base and intermediate classes.
class Vehicle
{
public $name;
public $color;
public function start()
{
// start login
}
public function stop()
{
// stop login
}
}
class Car extends Vehicle
{
function __construct(string $name, string $color)
{
$this->name = $name;
$this->color = $color;
}
public function carInfo()
{
echo "Car name: $this->name\n";
echo "Car color: $this->color\n";
}
}
class ElectricCar extends Car
{
private $batteryCapacity;
function __construct(string $name, string $color, int $batteryCapacity)
{
$this->name = $name;
$this->color = $color;
$this->batteryCapacity = $batteryCapacity;
}
public function electricCarInfo()
{
echo "Electric Car name: $this->name\n";
echo "Electric Car color: $this->color\n";
echo "Battery Capacity: {$this->batteryCapacity} kWh\n";
}
}
$teslaModelS = new ElectricCar('Tesla Model S', 'Black', 100);
$teslaModelS->start();
$teslaModelS->electricCarInfo();
$teslaModelS->stop();
In this example, the Vehicle class has been inherited by the Car class, and finally, the Car class has been inherited by the ElectricCar class. As a result, this demonstrates Multi-level Inheritance in action.
I hope this lesson has provided you with a fundamental understanding of the discussed topics. That’s all for today—see you in the next lesson! 😊
Top comments (0)