PHP Object-Oriented Programming (OOP) Basics

Object-Oriented Programming (OOP) in PHP is a programming paradigm that utilizes "objects" to represent data and methods. This guide provides a beginner-friendly overview of the fundamental concepts of OOP in PHP.

Key Concepts

1. Classes and Objects

• Class: A blueprint for creating objects that defines properties (attributes) and methods (functions).
• Object: An instance of a class, encapsulating specific data and capable of utilizing the methods defined in the class.

Example:

class Car {
    public $color;
    public $model;

    public function __construct($color, $model) {
        $this->color = $color;
        $this->model = $model;
    }
    
    public function displayInfo() {
        return "Car model: " . $this->model . ", Color: " . $this->color;
    }
}

// Creating an object
$myCar = new Car("Red", "Toyota");
echo $myCar->displayInfo(); // Outputs: Car model: Toyota, Color: Red

2. Encapsulation

• Encapsulation restricts access to certain components of an object using access modifiers:
  • public: Accessible from anywhere.
  • private: Accessible only within the class.
  • protected: Accessible within the class and by inheriting classes.

Example:

class BankAccount {
    private $balance = 0;

    public function deposit($amount) {
        $this->balance += $amount;
    }

    public function getBalance() {
        return $this->balance;
    }
}

3. Inheritance

• Inheritance allows the creation of a new class based on an existing class, granting the new class access to properties and methods of the parent class.
• The new class is termed a child class, while the class it inherits from is known as a parent class.

Example:

class Vehicle {
    public function start() {
        return "Vehicle started";
    }
}

class Bike extends Vehicle {
    public function pedal() {
        return "Bike pedaled";
    }
}

$myBike = new Bike();
echo $myBike->start(); // Outputs: Vehicle started
echo $myBike->pedal(); // Outputs: Bike pedaled

4. Polymorphism

• Polymorphism enables the utilization of a single interface to represent different types of objects, achievable through method overriding and interfaces.

Example of Method Overriding:

class Animal {
    public function sound() {
        return "Some sound";
    }
}

class Dog extends Animal {
    public function sound() {
        return "Bark";
    }
}

$myDog = new Dog();
echo $myDog->sound(); // Outputs: Bark

Conclusion

PHP's OOP paradigm facilitates better code organization and modularization. By employing classes and objects, developers can create more complex and reusable code structures, enhancing application maintainability and extensibility. Mastering the concepts of classes, encapsulation, inheritance, and polymorphism is essential for effective OOP in PHP.