PHP OOP - Object Oriented Programming Introduction

Object Oriented Programming (OOP) is a fundamental programming paradigm widely used in modern PHP development. It enables developers to model real-world entities as "objects" and organize code into reusable, maintainable structures called classes. This tutorial offers a practical introduction to PHP OOP, emphasizing core concepts, best practices, and hands-on examples to get you started.

Prerequisites

Basic knowledge of PHP syntax
Understanding of procedural programming concepts
Access to a PHP environment (PHP 7.4+ recommended)

Setup Steps

Install PHP: Make sure you have PHP installed. Check your PHP version by running:
```
php -v
```
Choose an editor: Use any text editor or IDE that supports PHP, such as VS Code, PhpStorm, or Sublime Text.
Create your project folder: Organize your PHP OOP projects in a dedicated folder.
Run PHP files: Use the built-in PHP server for testing:
```
php -S localhost:8000
```

What is PHP OOP?

OOP in PHP allows you to define classes which serve as blueprints for objects. Classes encapsulate data (properties) and behaviors (methods) related to a specific concept or entity. By organizing code this way, you can improve code reusability, readability, and maintainability.

Core Concepts Explained with Examples

1. Classes and Objects

A class is a blueprint for creating objects. An object is an instance of a class.

<?php
// Define a class named Car
class Car {
    // Properties
    public $brand;
    public $color;

    // Constructor method to initialize properties
    public function __construct($brand, $color) {
        $this->brand = $brand;
        $this->color = $color;
    }

    // Method to display car details
    public function display() {
        echo "Brand: " . $this->brand . ", Color: " . $this->color;
    }
}

// Create an object of the Car class
$myCar = new Car("Toyota", "Red");
$myCar->display();  // Output: Brand: Toyota, Color: Red
?>

2. Properties and Methods

Properties hold object data, while methods define behaviors. Both can have different access modifiers such as public, protected, and private.

3. Inheritance

Inheritance lets you create a child class that inherits properties and methods from a parent class, enabling code reuse.

<?php
// Parent class
class Vehicle {
    public $type;

    public function info() {
        echo "This is a " . $this->type;
    }
}

// Child class inheriting Vehicle
class Bike extends Vehicle {
    public function bikeInfo() {
        echo "Bike type: " . $this->type;
    }
}

$myBike = new Bike();
$myBike->type = "Mountain Bike";
$myBike->info();      // Output: This is a Mountain Bike
$myBike->bikeInfo();  // Output: Bike type: Mountain Bike
?>

4. Encapsulation

Encapsulation restricts direct access to object properties and forces usage of getter and setter methods.

<?php
class Person {
    private $name;

    public function setName($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

$person = new Person();
$person->setName("John");
echo $person->getName();  // Output: John
?>

5. Polymorphism

Polymorphism allows methods to behave differently based on the object type. It is often implemented with method overriding.

<?php
class Animal {
    public function sound() {
        echo "Generic animal sound";
    }
}

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

$animal = new Animal();
$dog = new Dog();

$animal->sound();  // Output: Generic animal sound
$dog->sound();     // Output: Bark
?>

Best Practices for PHP OOP

Use meaningful class and property names: This improves code readability.
Keep methods focused: Each method should have a single, clear responsibility.
Encapsulate properties: Use private or protected access modifiers with getters and setters.
Favor composition over inheritance: Composition improves flexibility by using objects as components.
Follow PSR standards: PSR-1 and PSR-12 define coding style guidelines for PHP.
Use namespaces: To organize and avoid class name conflicts in larger projects.

Common Mistakes in PHP OOP

Not using constructors for initialization and manually setting properties.
Exposing properties as public unnecessarily, leading to poor encapsulation.
Misunderstanding inheritance, e.g., creating deep inheritance trees that are hard to maintain.
Overusing inheritance where composition would be more appropriate.
Forgetting the $this keyword when accessing properties or methods.

Interview Questions

Junior-Level

Q1: What is a class in PHP OOP?
A: A class is a blueprint for creating objects containing properties and methods.
Q2: How do you create an object from a class?
A: Use the new keyword, e.g., $obj = new ClassName();.
Q3: What does the $this keyword represent?
A: It refers to the current object instance inside class methods.
Q4: What is the purpose of a constructor in PHP classes?
A: To initialize property values when an object is created.
Q5: Can properties be public in PHP OOP?
A: Yes, but it is best to use private/protected for encapsulation.

Mid-Level

Q1: Explain encapsulation with an example.
A: Restricting access to properties using private visibility and exposing getter/setter methods.
Q2: How does inheritance work in PHP?
A: A child class can inherit properties and methods from a parent class using the extends keyword.
Q3: What is method overriding?
A: Redefining a method in a child class that exists in the parent class.
Q4: How do you define a class constant in PHP?
A: Use the const keyword inside a class, e.g., const STATUS = 'active';.
Q5: What is the difference between public, protected, and private properties?
A: Public properties are accessible anywhere; protected inside the class and subclasses; private only inside the class.

Senior-Level

Q1: How would you implement polymorphism in PHP?
A: Using method overriding in child classes or interfaces where different classes implement the same methods.
Q2: What are namespaces and why are they important in PHP OOP?
A: Namespaces prevent class name collisions by organizing classes into distinct logical groups.
Q3: What is the SOLID principle and how does it apply to PHP OOP?
A: Set of design principles to write maintainable OOP code: Single responsibility, Open/closed, Liskov substitution, Interface segregation, Dependency inversion.
Q4: How can you implement dependency injection in PHP classes?
A: By passing dependencies through constructor or setter methods instead of instantiating inside the class.
Q5: Explain traits and how are they used in PHP.
A: Traits are reusable sets of methods that classes can include to avoid multiple inheritance limitations.

Frequently Asked Questions (FAQ)

Q1: What PHP version supports OOP features?

PHP has supported basic OOP features since PHP 5.x. Modern versions (PHP 7 and 8) offer improved performance and additional features.

Q2: Can a PHP class have multiple constructors?

PHP does not support multiple constructors, but you can simulate it using optional parameters or static factory methods.

Q3: What is the difference between a class and an object?

A class is a blueprint, while an object is an instance of that blueprint with actual data.

Q4: How do I access a static property in a class?

Use the scope resolution operator (::), e.g., ClassName::$propertyName;

Q5: Can I extend multiple classes in PHP?

No, PHP does not support multiple inheritance, but traits can be used to include methods from multiple sources.

Conclusion

Understanding PHP OOP is essential for modern PHP development. This introduction covered key OOP concepts such as classes, objects, inheritance, encapsulation, and polymorphism with practical examples. Applying best practices and avoiding common pitfalls will lead to clean, scalable code. With this foundation, you are well-prepared to explore more advanced OOP features and design patterns in PHP.

PHP OOP Introduction