PHP OOP Basics: Classes and Objects

Welcome to the world of Object-Oriented Programming (OOP) in PHP! 🚀 In this comprehensive guide, we’ll dive deep into the fundamental concepts of classes and objects, the building blocks of OOP. By the end of this article, you’ll have a solid understanding of how to create and use classes and objects in PHP, setting you on the path to writing more organized, reusable, and maintainable code.

Table of Contents

Understanding Classes in PHP

A class in PHP is a blueprint or template for creating objects. It defines the properties (attributes) and methods (functions) that the objects of that class will have. Think of a class as a cookie cutter, and the objects as the cookies it produces.

Let’s start with a simple example:

class Car {
    // Properties
    public $brand;
    public $model;
    public $year;

    // Method
    public function getInfo() {
        return "This is a {$this->year} {$this->brand} {$this->model}.";
    }
}

In this example, we’ve defined a Car class with three properties ($brand, $model, and $year) and one method (getInfo()). Let’s break down the components:

The class keyword is used to declare a class, followed by the class name (in this case, Car).
Properties are variables that belong to the class. They’re defined with visibility keywords (public, private, or protected).
Methods are functions that belong to the class. They can access and manipulate the class properties.

💡 Pro Tip: Class names in PHP are conventionally written in PascalCase (each word capitalized, no spaces).

Creating Objects from Classes

Now that we have our Car class, let’s create some objects (instances) of this class:

// Creating objects
$car1 = new Car();
$car2 = new Car();

// Setting property values
$car1->brand = "Toyota";
$car1->model = "Corolla";
$car1->year = 2022;

$car2->brand = "Honda";
$car2->model = "Civic";
$car2->year = 2023;

// Using the getInfo() method
echo $car1->getInfo() . "\n";
echo $car2->getInfo() . "\n";

When we run this code, we get the following output:

This is a 2022 Toyota Corolla.
This is a 2023 Honda Civic.

Let’s analyze what’s happening here:

We use the new keyword to create objects of the Car class.
We can access and set the properties of each object using the arrow (->) operator.
We call the getInfo() method on each object to get a formatted string about the car.

🔍 Note: Each object is a separate instance of the class, with its own set of property values.

Constructors: Initializing Objects

In the previous example, we manually set the properties after creating the objects. PHP allows us to automate this process using a special method called a constructor. The constructor is called automatically when an object is created.

Let’s modify our Car class to include a constructor:

class Car {
    public $brand;
    public $model;
    public $year;

    // Constructor
    public function __construct($brand, $model, $year) {
        $this->brand = $brand;
        $this->model = $model;
        $this->year = $year;
    }

    public function getInfo() {
        return "This is a {$this->year} {$this->brand} {$this->model}.";
    }
}

// Creating objects with constructor
$car1 = new Car("Toyota", "Corolla", 2022);
$car2 = new Car("Honda", "Civic", 2023);

echo $car1->getInfo() . "\n";
echo $car2->getInfo() . "\n";

The output remains the same, but our code is now more concise and efficient. The constructor (__construct()) is called automatically when we create new Car objects, initializing the properties with the values we provide.

Adding More Functionality

Let’s expand our Car class with some additional properties and methods to demonstrate more OOP concepts:

class Car {
    public $brand;
    public $model;
    public $year;
    private $mileage = 0;

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

    public function getInfo() {
        return "This is a {$this->year} {$this->brand} {$this->model}.";
    }

    public function drive($distance) {
        $this->mileage += $distance;
        return "Drove {$distance} miles. Total mileage: {$this->mileage} miles.";
    }

    public function getMileage() {
        return $this->mileage;
    }
}

// Using the expanded Car class
$car = new Car("Tesla", "Model 3", 2023);
echo $car->getInfo() . "\n";
echo $car->drive(100) . "\n";
echo $car->drive(50) . "\n";
echo "Final mileage: " . $car->getMileage() . " miles\n";

This code produces the following output:

This is a 2023 Tesla Model 3.
Drove 100 miles. Total mileage: 100 miles.
Drove 50 miles. Total mileage: 150 miles.
Final mileage: 150 miles

Let’s break down the new additions:

We added a private property $mileage, which can only be accessed within the class.
The drive() method increases the mileage and returns a status message.
The getMileage() method allows us to retrieve the mileage value from outside the class.

🔒 Access Modifiers:

public: Accessible from anywhere
private: Only accessible within the class
protected: Accessible within the class and its subclasses (we’ll cover this in inheritance)

Static Properties and Methods

Sometimes, you might want properties or methods that belong to the class itself, rather than to instances of the class. These are called static properties and methods. Let’s add a static property to keep track of the total number of cars created:

class Car {
    public $brand;
    public $model;
    public $year;
    private $mileage = 0;
    private static $totalCars = 0;

    public function __construct($brand, $model, $year) {
        $this->brand = $brand;
        $this->model = $model;
        $this->year = $year;
        self::$totalCars++;
    }

    // ... (previous methods remain the same)

    public static function getTotalCars() {
        return self::$totalCars;
    }
}

// Using static methods and properties
$car1 = new Car("Toyota", "Corolla", 2022);
$car2 = new Car("Honda", "Civic", 2023);
$car3 = new Car("Tesla", "Model 3", 2023);

echo "Total cars created: " . Car::getTotalCars() . "\n";

This will output:

Total cars created: 3

Key points about static properties and methods:

They are declared using the static keyword.
They are accessed using the scope resolution operator (::).
Inside the class, we use self:: to refer to static properties.
Static methods can be called without creating an instance of the class.

Practical Example: Building a Simple Inventory System

Let’s put everything we’ve learned together by creating a simple inventory system for a bookstore:

class Book {
    public $title;
    public $author;
    public $price;
    private static $inventory = [];

    public function __construct($title, $author, $price) {
        $this->title = $title;
        $this->author = $author;
        $this->price = $price;
        self::$inventory[] = $this;
    }

    public static function listInventory() {
        echo "Current Inventory:\n";
        echo str_repeat('-', 50) . "\n";
        echo sprintf("%-30s %-20s %s\n", "Title", "Author", "Price");
        echo str_repeat('-', 50) . "\n";
        foreach (self::$inventory as $book) {
            echo sprintf("%-30s %-20s $%.2f\n", $book->title, $book->author, $book->price);
        }
    }

    public static function getTotalValue() {
        return array_reduce(self::$inventory, function($total, $book) {
            return $total + $book->price;
        }, 0);
    }
}

// Adding books to inventory
new Book("The Great Gatsby", "F. Scott Fitzgerald", 12.99);
new Book("To Kill a Mockingbird", "Harper Lee", 14.99);
new Book("1984", "George Orwell", 11.99);
new Book("Pride and Prejudice", "Jane Austen", 9.99);

// Listing inventory
Book::listInventory();

// Getting total inventory value
echo "\nTotal Inventory Value: $" . number_format(Book::getTotalValue(), 2);

This script will produce the following output:

Current Inventory:
--------------------------------------------------
Title                          Author               Price
--------------------------------------------------
The Great Gatsby               F. Scott Fitzgerald  $12.99
To Kill a Mockingbird          Harper Lee           $14.99
1984                           George Orwell        $11.99
Pride and Prejudice            Jane Austen          $9.99

Total Inventory Value: $49.96

In this example, we’ve created a Book class that:

Automatically adds each new book to a static inventory array.
Provides a method to list all books in the inventory.
Calculates the total value of all books in stock.

This demonstrates how OOP can be used to create organized, scalable systems with ease.

Conclusion

Congratulations! 🎉 You’ve just taken a deep dive into the world of PHP OOP basics, focusing on classes and objects. We’ve covered:

Creating classes and objects
Using constructors for object initialization
Working with public and private properties
Implementing methods
Utilizing static properties and methods
Building a practical inventory system

Object-Oriented Programming is a powerful paradigm that allows for more organized, reusable, and maintainable code. As you continue your PHP journey, you’ll discover even more advanced OOP concepts like inheritance, interfaces, and polymorphism.

Remember, practice makes perfect! Try creating your own classes and objects, and experiment with different scenarios to solidify your understanding. Happy coding! 💻🚀