How to start learning PHP OOP – Object-oriented Programming in PHP

If you are interested in web development, PHP is one of the most popular web programming languages to learn. It is used for creating dynamic websites and web applications. In recent years, there has been a shift towards object-oriented programming (OOP) in PHP. OOP is a programming paradigm that allows you to create reusable code and simplify complex applications. In this post, we will discuss how to start learning OOP in PHP and provide examples to help you understand the concepts.

What is Object-Oriented Programming?

Object-oriented programming (OOP) is a programming paradigm that focuses on the use of objects. Objects are instances of classes, which are like blueprints for creating objects. In OOP, data and behavior are encapsulated within objects, making it easier to reuse code and create modular applications. OOP concepts include inheritance, encapsulation, polymorphism, and abstraction.

Getting Started with PHP OOP

To get started with PHP OOP, you should have a basic understanding of PHP syntax and concepts such as variables, functions, and loops. If you are new to PHP, you may want to start with a beginner’s tutorial on PHP syntax and then move on to OOP concepts.

Classes and Objects

In OOP, a class is a blueprint for creating objects. A class can contain properties, which are variables that store data, and methods, which are functions that perform actions. To create an object from a class, you use the new keyword.
Here is an example of a class in PHP:

class Car {
public $make;
public $model;

public function __construct($make, $model) {
$this->make = $make;
$this->model = $model;
}

public function getInfo() {
return “Make: ” . $this->make . ” | Model: ” . $this->model;
}
}

$car1 = new Car(“Ford”, “Mustang”);
echo $car1->getInfo(); // Output: Make: Ford | Model: Mustang

In this example, we have created a Car class with two properties: $make and $model. We have also defined a constructor method, which is called when a new object is created. The constructor method takes two arguments, $make and $model, and sets the corresponding properties. Finally, we have defined a method called getInfo, which returns a string containing the make and model of the car. We create a new Car object and call the getInfo method to output the car information.

Inheritance

Inheritance is a concept in OOP where a class can inherit properties and methods from another class. The class that is being inherited from is called the parent class or super class, and the class that is inheriting is called the child class or subclass.

Here is an example of inheritance in PHP:

class Animal {
protected $name;
protected $species;

public function __construct($name, $species) {
$this->name = $name;
$this->species = $species;
}

public function getInfo() {
return “Name: ” . $this->name . ” | Species: ” . $this->species;
}
}

class Dog extends Animal {
private $breed;

public function __construct($name, $breed) {
parent::__construct($name, “Canine”);
$this->breed = $breed;
}

public function getInfo() {
return parent::getInfo() . ” | Breed: ” . $this->breed;
}
}

$dog1 = new Dog(“Max”, “Labrador Retriever”);
echo $dog1->getInfo(); // Output: Name: Max | Species: Canine | Breed: Labrador Retriever

In this example, we have a parent class called Animal with two properties, $name and $species, and a constructor method that sets these properties. The Animal class also has a getInfo method that returns the animal’s name and species.

The Dog class extends the Animal class using the extends keyword and adds its own property called $breed. The Dog class also has its own constructor method that calls the parent constructor and sets the $breed property. Finally, the Dog class overrides the parent getInfo method and adds the breed to the output.

Abstraction

Abstraction is a concept in OOP where you create classes that provide a general overview of the behavior and properties of a set of objects, without specifying the exact implementation details. Abstraction helps you to reduce complexity and increase flexibility in your code.
Here is an example of abstraction in PHP:

abstract class Shape {
protected $color;

public function __construct($color) {
$this->color = $color;
}

abstract public function area();
}

class Circle extends Shape {
private $radius;

public function __construct($color, $radius) {
parent::__construct($color);
$this->radius = $radius;
}

public function area() {
return pi() * pow($this->radius, 2);
}
}

class Square extends Shape {
private $length;

public function __construct($color, $length) {
parent::__construct($color);
$this->length = $length;
}

public function area() {
return pow($this->length, 2);
}
}

$circle1 = new Circle(“Red”, 5);
echo $circle1->area(); // Output: 78.539816339745

$square1 = new Square(“Blue”, 4);
echo $square1->area(); // Output: 16

In this example, we have an abstract class called Shape that defines a constructor method and an abstract method called area. The area method is not implemented in the Shape class, but instead is implemented in the child classes, Circle and Square.

The Circle and Square classes extend the Shape class and implement their own area methods. These methods use the specific formula for calculating the area of a circle or square, but they both inherit the $color property and the constructor method from the Shape class.

Encapsulation

Encapsulation is a concept in OOP where data and behavior are contained within an object and can only be accessed through the object’s methods. This provides a level of security and prevents data from being modified or accessed outside of the object.

Here is an example of encapsulation in PHP:

class BankAccount {
private $balance;

public function __construct($balance) {
$this->balance = $balance;
}

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

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

public function withdraw($amount) {
if ($amount > $this->balance) {
return “Insufficient funds.”;
} else {
$this->balance -= $amount;
}
}
}

$account1 = new BankAccount(1000);
echo $account1->getBalance(); // Output: 1000

$account1->deposit(500);
echo $account1->getBalance(); // Output: 1500

echo $account1->withdraw(2000); // Output: Insufficient funds.

echo $account1->getBalance(); // Output: 1500

In this example, we have a BankAccount class with a private $balance property. The BankAccount class also has methods for getting the balance, depositing money, and withdrawing money.

The $balance property is encapsulated because it is private, meaning it cannot be accessed or modified outside of the BankAccount class. Instead, the balance can only be accessed or modified using the class’s methods, getBalance, deposit, and withdraw.

Conclusion

Learning PHP OOP can seem daunting at first, but it can provide a lot of benefits in terms of code organization, flexibility, and reusability. By understanding the core concepts of PHP OOP, such as classes, objects, properties, methods, inheritance, abstraction, and encapsulation, you can create more efficient and scalable code.

To get started with PHP OOP, try creating simple classes and objects, and gradually build up to more complex examples. Experiment with inheritance, abstraction, and encapsulation, and see how these concepts can help you create more organized and secure code.

Don’t be afraid to make mistakes and experiment with different approaches. As with any skill, practice makes perfect, and the more you practice PHP OOP, the more confident and comfortable you will become with this powerful programming paradigm.