How to Use PHP Classes for Object-Oriented Programming

Understanding Object-Oriented PHP

PHP is a powerful, object-oriented scripting language. But what does that actually mean? It means that developers have a great way to organize code into logical, self-contained units, making it incredibly easy to re-use chunks of code across different applications. The core entities of this paradigm are classes and objects.

The whole point of an object-oriented language is to make everything better, more scalable, and significantly more secure. The main problem is that object-oriented PHP can be a difficult concept to grasp if you have never used it before, especially if you are used to procedural scripting.

Why Use Object-Oriented PHP At All?

In times gone by before the days of object-oriented PHP, everything would be put into simple functions. Each function would be a chunk of code that completes a task and you call it from elsewhere in your code. You could send it values, variables, and arrays. Now, functions are all very well, and are great for organizing small projects, but when you get into larger projects you will start running into significant problems with namespace collisions and spaghetti code.

Object-oriented programming really shows its strengths when you start to build bigger, more complex projects. Mass organization becomes easier and more robust. Teams of developers can operate independently with little fear of interfering with each other's variable names or application state. This kind of robustness simply isn’t possible using traditional functions.

How to Use Object-Oriented PHP

Object-oriented programming revolves primarily around classes. Classes are basically the logical containers for your functions and application state. Except, to make things a bit more formal, the functions aren’t called functions in object-orientated PHP; they are called methods. Variables within a class are called properties.

<?php
class First {
    // do something
}
?>

You can then use your class within your code by creating a new instance of it (an object):

<?php
$result = new First();
?>

Now obviously our class doesn’t do anything because we haven’t added anything to our class structure, but we have created a basic foundational class.

How to Make the Class Do Something

In order to make the class do something, we need to add a few structural elements to it. We need to add properties that we can use to store data, and methods that will do the computational work for us.

In Object-Oriented development, we usually implement two standard methods at a minimum for interacting with private properties. These are the setter and getter methods, ensuring safe encapsulation of data.

<?php
class First {
    public $name;
    
    public function set_name($new_name) {
        $this->name = $new_name;
    }

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

All this probably looks a bit confusing, but it's all really quite simple. It all looks confusing because of the $this-> syntax. The $this keyword is simply a built-in variable that points directly to the current object instance. PHP knows exactly what to do when it comes across this contextual keyword.

Let's Use Our PHP Class

Now we have a fully functioning class, one that actually does something. So how do we use it in a real-world application? We create an instance of the object in the server's memory:

<?php
$andy = new First();
$steve = new First();
?>

We now have two handles to our class. Both use the exact same class blueprint, just a different instance of it in memory. Seeing this, it slowly becomes clear how much simpler your application architecture could become. You can use the same class as many times as you like and just set different handles to each instance and perform different operations on each instance. For example, we can set a different string name to each one:

<?php
$andy = new First();
$steve = new First();

$andy->set_name("Andy Kay");
$steve->set_name("Steven Smith");
?>

Now this code doesn’t actually display anything on the screen, but we have initialized two objects and securely set their internal properties. It should be explicitly noted that $andy and $steve are completely separate entities; the only thing that relates them is that they use the same structural class, but they are completely different objects in the eyes of the PHP interpreter.

How to Retrieve the Results?

When accessing methods and properties of an instantiated class, you use the object operator (arrow ->). So to retrieve our stored names that we securely set earlier, we invoke the getter methods:

<?php
$andy = new First();
$steve = new First();

$andy->set_name("Andy Kay");
$steve->set_name("Steven Smith");

echo $andy->get_name() . "<br />";
echo $steve->get_name();
?>

These are the absolute fundamentals, but as you become more involved with complex applications, you will realize the true power of OOP. If you want to get anywhere in modern PHP development frameworks, you need to be using an object-oriented approach.

Classes are created in much the same way as standalone functions are in procedural PHP, except instead of the keyword function for the main block, we use class. Once mastered, this pattern unlocks advanced design patterns and scalable architecture.

Frequently Asked Questions (FAQ)

Why use object-oriented PHP instead of functions?

Object-oriented PHP makes large projects more organized and robust by using classes and encapsulation, avoiding variable name conflicts and improving code reusability compared to procedural function-based scripting.

What are methods and properties in PHP?

Properties are variables defined inside a class, while methods are functions defined within the class that operate on those properties and provide the class's behavior.