Part 1.1: What is OOP?
Object-Oriented Programming (OOP) is a programming paradigm that uses "objects" to design applications and programs. These objects are created using classes, which are essentially blueprints for creating an object.
An object is a self-contained entity that consists of both data and procedures to manipulate the data. The data is referred to as properties, and the procedures are referred to as methods.
Part 1.2: Why use OOP?
OOP offers several benefits over procedural programming:
- Modularity: The source code for an object can be written and maintained independently of the source code for other objects. Once created, an object can be easily passed around in the system.
- Information-hiding: By interacting only with an object's methods, the details of its internal implementation remain hidden from the outside world.
- Code reusability: If an object already exists (perhaps written by another software developer), you can use that object in your program. This eliminates the need to write the same code again.
- Easy Maintenance and Modification: Existing code can be modified with new requirements by adding a few methods or changing a few methods, instead of changing the entire code.
- Design Benefits: Large complex applications can be easily designed and maintained with the help of OOPs.
Part 1.3: Classes and Objects in PHP
In PHP, a class is an entity that determines how an object will behave and what the object will contain. In other words, it is a blueprint or a set of instructions to build a specific type of object.
Here's an example of a simple class definition:
class Employee {
// Class body goes here
}
An object is an instance of a class, and PHP allows us to create multiple objects of a class. Here's how to create an object:
$employee1 = new Employee();
$employee2 = new Employee();
In the example above, $employee1 and $employee2 are objects of the Employee class.
Part 1.4: Properties and Methods
Properties and methods are defined inside a class. Properties are variables that hold data, and methods are functions that perform actions.
class Employee {
// Property
public $name;
// Method
public function setName($name) {
$this->name = $name;
}
}
In the example above, $name is a property and setName() is a method. The $this keyword is used to access properties and methods from within the class.
This is a basic introduction to OOP in PHP. As you continue to learn, you'll encounter more advanced topics such as inheritance, polymorphism, encapsulation, and more.
Part 1.5: The $this Keyword
In PHP, the $this keyword is used to refer to the calling object in a class. It's a reference to the current object, and it's only available inside methods.
class Employee {
public $name;
public function setName($name) {
$this->name = $name;
}
}
In the example above, $this->name refers to the $name property of the current Employee object.
Part 1.6: Access Modifiers
Access modifiers are keywords that set the accessibility of properties and methods. PHP supports three access modifiers:
public– the property or method can be accessed from everywhere. This is the default if you don't specify an access modifier.protected– the property or method can be accessed within the class and by classes derived from that class.private– the property or method can ONLY be accessed within the class.
class Employee {
public $name;
protected $department;
private $salary;
}
In the example above, $name can be accessed from anywhere, $department can be accessed within the Employee class and any class that extends Employee, and $salary can only be accessed within the Employee class.
Part 1.7: The __construct() Method
The __construct() method is a special method in PHP called a constructor. It is automatically called whenever a new object is created.
class Employee {
public $name;
public function __construct($name) {
$this->name = $name;
}
}
$employee = new Employee("John Doe");
echo $employee->name; // Outputs: John Doe
In the example above, when we create a new Employee object, we pass "John Doe" to the constructor, which sets the $name property.
Part 1.8: The __destruct() Method
The __destruct() method is another special method in PHP called a destructor. It is automatically called when an object is destroyed or the script ends.
class Employee {
public $name;
public function __construct($name) {
$this->name = $name;
}
public function __destruct() {
echo "The object is being destroyed.";
}
}
$employee = new Employee("John Doe");
// Outputs: The object is being destroyed.
In the example above, when the script ends, the destructor is called, and "The object is being destroyed." is printed.
This concludes the detailed introduction to OOP in PHP. The next parts would cover more advanced topics such as inheritance, interfaces, abstract classes, and more.
Part 1.9: Inheritance
Inheritance is a fundamental principle of Object-Oriented Programming where one class can inherit properties and methods from another class. This helps in reusing the code and makes the program more modular.
In PHP, inheritance is implemented using the extends keyword.
Here's an example:
class Employee {
public $name;
public $age;
public function __construct($name, $age) {
$this->name = $name;
$this->age = $age;
}
public function work() {
echo "Working";
}
}
class Manager extends Employee {
public $teamSize;
public function manage() {
echo "Managing";
}
}
$manager = new Manager("John Doe", 35);
$manager->teamSize = 5;
echo $manager->name; // Outputs: John Doe
echo $manager->age; // Outputs: 35
echo $manager->teamSize; // Outputs: 5
$manager->work(); // Outputs: Working
$manager->manage(); // Outputs: Managing
In the example above, Manager is a subclass of Employee, and Employee is a superclass of Manager. The Manager class inherits the $name, $age properties and the work() method from the Employee class, and it also has its own property $teamSize and method manage().
Part 1.10: Overriding Methods
In the context of object-oriented programming, method overriding is a feature that allows a subclass to provide a different implementation of a method that is already defined in its superclass.
Here's an example:
class Employee {
public function work() {
echo "Working";
}
}
class Manager extends Employee {
public function work() {
echo "Managing";
}
}
$employee = new Employee();
$employee->work(); // Outputs: Working
$manager = new Manager();
$manager->work(); // Outputs: Managing
In the example above, the Manager class overrides the work() method of the Employee class.
Part 1.11: Polymorphism
Polymorphism is a concept in OOP that allows objects to be treated as instances of their parent class. This means that we can have a method that, for example, takes an Employee object, but we can pass it instances of Employee and any subclasses of Employee.
class Employee {
public function work() {
echo "Working";
}
}
class Manager extends Employee {
public function work() {
echo "Managing";
}
}
function makeThemWork(Employee $employee) {
$employee->work();
}
$employee = new Employee();
$manager = new Manager();
makeThemWork($employee); // Outputs: Working
makeThemWork($manager); // Outputs: Managing
In the example above, the makeThemWork() function takes an Employee object, but we can pass it an Employee object or a Manager object, because Manager is a subclass of Employee.
This concludes the detailed introduction to OOP in PHP. The next parts would cover more advanced topics such as interfaces, abstract classes, and more.
Part 1.12: Abstract Classes
Abstract classes are classes that contain at least one abstract method. An abstract method is a method that is declared, but not implemented in the code.
Abstract classes cannot be instantiated, and any class that contains at least one abstract method must also be abstract. Classes defined as abstract may only be extended.
Here's an example:
abstract class Employee {
public $name;
public function __construct($name) {
$this->name = $name;
}
abstract public function work();
}
class Manager extends Employee {
public function work() {
echo "Managing";
}
}
$manager = new Manager("John Doe");
$manager->work(); // Outputs: Managing
In the example above, Employee is an abstract class with an abstract method work(). Manager is a class that extends Employee and provides an implementation for the work() method.
Part 1.13: Interfaces
Interfaces are defined to provide a common function names to the implementors. Different implementors can implement those interfaces according to their requirements. You can say, interfaces are skeletons which are implemented by developers.
Here's an example:
interface Worker {
public function work();
}
class Employee implements Worker {
public function work() {
echo "Working";
}
}
class Manager implements Worker {
public function work() {
echo "Managing";
}
}
function makeThemWork(Worker $worker) {
$worker->work();
}
$employee = new Employee();
$manager = new Manager();
makeThemWork($employee); // Outputs: Working
makeThemWork($manager); // Outputs: Managing
In the example above, Worker is an interface with a method work(). Both Employee and Manager classes implement the Worker interface and provide their own implementation of the work() method.
Part 1.14: Traits
Traits are a mechanism for code reuse in single inheritance languages such as PHP. A Trait is intended to reduce some limitations of single inheritance by enabling a developer to reuse sets of methods freely in several independent classes living in different class hierarchies.
Here's an example:
trait WorkTrait {
public function work() {
echo "Working";
}
}
class Employee {
use WorkTrait;
}
class Manager {
use WorkTrait;
}
$employee = new Employee();
$employee->work(); // Outputs: Working
$manager = new Manager();
$manager->work(); // Outputs: Working
In the example above, WorkTrait is a trait with a method work(). Both Employee and Manager classes use the WorkTrait trait, so they both have a work() method.
This concludes the detailed introduction to OOP in PHP. As you continue to learn, you'll encounter PHP for Practical Learning: A Step-by-Step Guide to Building a Food Delivery Website
