Object-Oriented PHP for Beginners: Classes, Objects, and Methods

Object-oriented PHP helps you organize code around classes, objects, and reusable behavior. Once your PHP scripts start growing beyond small examples, OOP gives you a clearer way to model users, products, orders, posts, and other real-world things.

This beginner guide explains classes, objects, properties, methods, constructors, and why OOP matters in modern PHP. If you are still learning the core language, start with PHP Syntax Basics and PHP Functions Explained with Practical Examples. The official PHP OOP manual is a useful reference.

Object-oriented PHP: what a class is

A class is a blueprint. It defines what data and behavior a thing should have. An object is a real instance created from that blueprint. In a product system, for example, the class might describe name, price, and stock. Each actual product becomes an object.

<?php
class Product
{
    public string $name;
    public float $price;
}

$product = new Product();
$product->name = 'Keyboard';
$product->price = 49.99;

Properties and methods

Properties store data. Methods are functions that belong to the class. Together, they let you keep related behavior in one place instead of scattering it across many procedural helper functions.

<?php
class CartItem
{
    public function __construct(
        public string $name,
        public float $price,
        public int $quantity = 1,
    ) {}

    public function subtotal(): float
    {
        return $this->price * $this->quantity;
    }
}

Here, the constructor builds a valid object in one step, and subtotal() calculates a value from the object’s own data. That pattern appears all over real applications.

Use objects to model real things

Object-oriented PHP is useful when you want code to reflect the domain. A blog post object may know its title and publish status. A user object may know its email and role. An order object may know its total and line items. The code becomes easier to read when the names match the problem.

Visibility and encapsulation

PHP lets you control whether a property or method is public, protected, or private. Public members are accessible from outside the class. Private members stay inside the class. That boundary helps you protect internal state and prevent accidental misuse.

When learning, start with public properties and methods to understand the flow. Then move toward private properties with small accessor methods when you need stricter control. The goal is not to hide everything; the goal is to expose only what the rest of the program truly needs.

A practical example

Imagine a shipping calculator:

<?php
class ShippingQuote
{
    public function __construct(
        private float $baseFee,
        private float $perKg
    ) {}

    public function calculate(float $weight): float
    {
        return $this->baseFee + ($this->perKg * $weight);
    }
}

This class keeps the shipping logic in one place. If the business rule changes later, you update one method instead of hunting through scattered formulas.

When to learn OOP in PHP

• When you start repeating the same logic in multiple files.
• When you need to represent real-world entities like users, posts, or orders.
• When you want cleaner structure for larger projects.
• When you are preparing for frameworks like Laravel or for WordPress plugin architecture.

OOP is not mandatory for every small script, but it becomes increasingly valuable as soon as your codebase grows past a few isolated helpers. Learn the basics early so the structure feels natural later.

Inheritance and composition

Inheritance lets one class reuse or extend another class. Composition means one object contains or uses other objects. Beginners often hear both terms early, but composition is usually the simpler and safer starting point because it keeps responsibilities smaller.

For example, a checkout object may use a cart object, a tax calculator, and a shipping calculator. That is composition. You are combining focused pieces instead of forcing one giant class to know everything.

Practical OOP example in PHP

<?php
class User
{
    public function __construct(
        private string $name,
        private string $email
    ) {}

    public function displayName(): string
    {
        return strtoupper($this->name);
    }
}

$user = new User('Tuyen', 'tuyen@example.com');
echo $user->displayName();

This example shows how a class can own its own behavior. The caller does not need to know how the name is formatted internally. It only needs the method result.

Why OOP matters for WordPress and Laravel

WordPress is still heavily procedural in many places, but modern plugins and larger codebases often use objects for services, repositories, settings, and API clients. Laravel uses objects and dependency injection throughout its structure. Understanding classes and methods now makes those ecosystems less intimidating later.

Start with small classes, clear constructors, and one method per behavior. That is enough to write maintainable PHP without jumping straight into advanced patterns too soon.

A simple habit helps a lot: name classes after nouns and methods after verbs. A User class can save(), displayName(), or isAdmin(). That naming pattern makes code feel less abstract when you are reading it later.

As you practice, try converting one old procedural script into a class-based version. That exercise reveals what belongs together and where the class boundary should sit.