Object-oriented programming (OOP) is a programming paradigm that focuses on creating objects that contain both data and methods to manipulate that data. PHP, a popular server-side scripting language, also supports OOP. In this article, we will explore the basics of OOP in PHP.
1. Classes and Objects:
In PHP, a class is a blueprint for creating objects. It defines the properties (variables) and methods (functions) that an object of that class will have. To create an object, we use the `new` keyword followed by the class name.
“`php
class Car {
public $color;
public function startEngine() {
echo "Engine started!";
}
}
$myCar = new Car();
$myCar->color = "red";
$myCar->startEngine(); // Output: Engine started!
“`
2. Properties and Methods:
Properties are variables that hold data, while methods are functions that perform actions. They are defined within a class and can be accessed using the object of that class.
“`php
class Car {
public $color;
public function startEngine() {
echo "Engine started!";
}
}
$myCar = new Car();
$myCar->color = "red";
$myCar->startEngine(); // Output: Engine started!
“`
3. Access Modifiers:
PHP provides three access modifiers to control the visibility of properties and methods within a class:
– `public`: The property or method can be accessed from anywhere.
– `protected`: The property or method can only be accessed within the class or its subclasses.
– `private`: The property or method can only be accessed within the class itself.
“`php
class Car {
public $color; // Public property
protected $model; // Protected property
private $price; // Private property
public function startEngine() { // Public method
echo "Engine started!";
}
protected function getModel() { // Protected method
return $this->model;
}
private function getPrice() { // Private method
return $this->price;
}
}
$myCar = new Car();
$myCar->color = "red"; // Accessible
$myCar->model = "XYZ"; // Not accessible (protected)
$myCar->price = 10000; // Not accessible (private)
$myCar->startEngine(); // Accessible
$myCar->getModel(); // Not accessible (protected)
$myCar->getPrice(); // Not accessible (private)
“`
4. Inheritance:
Inheritance allows a class to inherit properties and methods from another class. The class that is being inherited from is called the parent class or superclass, while the class that inherits is called the child class or subclass. In PHP, we use the `extends` keyword to implement inheritance.
“`php
class Vehicle {
public $color;
public function startEngine() {
echo "Engine started!";
}
}
class Car extends Vehicle {
public $model;
public function getModel() {
return $this->model;
}
}
$myCar = new Car();
$myCar->color = "red"; // Inherited from Vehicle class
$myCar->model = "XYZ";
$myCar->startEngine(); // Inherited from Vehicle class
echo $myCar->getModel(); // Output: XYZ
“`
5. Polymorphism:
Polymorphism allows objects of different classes to be treated as objects of a common parent class. This enables us to write code that can work with objects of different types without needing to know their specific class.
“`php
class Animal {
public function makeSound() {
echo "Animal makes a sound!";
}
}
class Dog extends Animal {
public function makeSound() {
echo "Dog barks!";
}
}
class Cat extends Animal {
public function makeSound() {
echo "Cat meows!";
}
}
$animals = array(new Dog(), new Cat());
foreach ($animals as $animal) {
$animal->makeSound();
}
// Output: Dog barks! Cat meows!
“`
These are just the basics of OOP in PHP. There are many more advanced concepts and features available, such as interfaces, abstract classes, and namespaces. Understanding and utilizing OOP can greatly improve the structure, reusability, and maintainability of your PHP code.