PHP is one of the most widely used server-side programming languages for building websites, APIs, content management systems, and business applications.

As PHP applications grow, writing everything as standalone functions can quickly become difficult to maintain. This is where PHP classes and objects become important.

Classes and objects are the foundation of Object-Oriented Programming (OOP) in PHP. They allow developers to organize related data and functionality into reusable, maintainable components.

In this complete guide, you’ll learn:

• What PHP classes are
• What PHP objects are
• How to create classes and objects
• Properties and methods
• Constructors and destructors
• Visibility modifiers
• Getters and setters
• $this keyword
• Static properties and methods
• Inheritance
• Method overriding
• Abstract classes
• Interfaces
• Traits
• Encapsulation
• Real-world examples
• Common mistakes
• PHP OOP best practices

---

What Are PHP Classes and Objects?

Before writing code, it is important to understand the difference between a class and an object.

A class is a blueprint.

An object is an actual instance created from that blueprint.

Think about a car:

                    Car Class
                       │
             ┌─────────┼─────────┐
             ↓         ↓         ↓
           Car 1     Car 2     Car 3
             │         │         │
          BMW       Toyota     Tesla

The Car class defines what a car can contain and do.

Each object created from the class can have different values.

For example:

Car Class
├── brand
├── model
├── color
└── start()

Objects
├── BMW X5
├── Toyota Camry
└── Tesla Model 3

---

What Is a Class in PHP?

A class is a template that defines properties and methods.

A simple PHP class looks like this:

<?php

class Car
{
    public string $brand;

    public function start(): string
    {
        return "The car has started.";
    }
}

Here:

public string $brand;

is a property.

And:

public function start(): string

is a method.

---

What Is an Object in PHP?

An object is an instance of a class.

You can create an object using the new keyword:

$car = new Car();

You can then access its property:

$car->brand = "Toyota";

And call its method:

echo $car->start();

The complete example:

<?php

class Car
{
    public string $brand;

    public function start(): string
    {
        return "The car has started.";
    }
}

$car = new Car();

$car->brand = "Toyota";

echo $car->brand;
echo $car->start();

---

PHP Class vs Object

Class	Object
Blueprint	Instance
Defines structure	Contains actual values
Doesn’t represent a specific instance	Represents a specific instance
Created using class	Created using new
Defines properties and methods	Uses those properties and methods

A simple way to remember it:

Class = blueprint, Object = actual thing created from the blueprint.

---

PHP Properties

Properties represent the data or state of an object.

For example:

class User
{
    public string $name;
    public string $email;
}

Create an object:

$user = new User();

$user->name = "John";
$user->email = "john@example.com";

Access the properties:

echo $user->name;
echo $user->email;

---

Typed Properties in PHP

Modern PHP supports typed properties.

Instead of:

public $name;

you can write:

public string $name;

Other common types include:

public int $age;

public float $price;

public bool $isActive;

public array $roles;

public ?string $phone;

Using types makes code easier to understand and can help catch incorrect values.

---

PHP Methods

Methods are functions defined inside a class.

For example:

class Calculator
{
    public function add(
        int $a,
        int $b
    ): int {
        return $a + $b;
    }
}

Create an object:

$calculator = new Calculator();

$result = $calculator->add(10, 20);

echo $result;

Output:

30

Methods represent behavior.

For example:

User
├── name
├── email
├── login()
└── logout()

Order
├── amount
├── status
├── calculateTotal()
└── cancel()

Product
├── name
├── price
├── updatePrice()
└── applyDiscount()

---

The $this Keyword in PHP

Inside a class, $this refers to the current object.

For example:

class User
{
    public string $name;

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

Create the object:

$user = new User();

$user->name = "Sarah";

echo $user->getName();

Here:

$this->name

means:

The name property belonging to the current object.

---

PHP Constructors

A constructor is automatically executed when an object is created.

PHP uses:

__construct()

for constructors.

Example:

class User
{
    public string $name;

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

Now create the object:

$user = new User("John");

echo $user->name;

Output:

John

---

Constructor Property Promotion

Modern PHP versions support constructor property promotion.

Instead of:

class User
{
    public string $name;
    public string $email;

    public function __construct(
        string $name,
        string $email
    ) {
        $this->name = $name;
        $this->email = $email;
    }
}

You can write:

class User
{
    public function __construct(
        public string $name,
        public string $email
    ) {
    }
}

This is shorter and cleaner.

---

Constructor Example With Validation

You can also enforce rules inside constructors.

class Product
{
    public function __construct(
        public string $name,
        public float $price
    ) {
        if ($price < 0) {
            throw new InvalidArgumentException(
                "Price cannot be negative."
            );
        }
    }
}

Now:

$product = new Product(
    "Laptop",
    75000
);

creates a valid object.

---

PHP Destructors

PHP also supports destructors using:

__destruct()

A destructor is called when an object is destroyed.

Example:

class Logger
{
    public function __destruct()
    {
        echo "Logger object destroyed.";
    }
}

Destructors are less commonly needed in everyday PHP application code, but they can be useful for cleanup operations in certain scenarios.

---

Visibility in PHP

PHP provides three main visibility modifiers:

public
protected
private

They control where properties and methods can be accessed.

---

Public Properties and Methods

A public member can be accessed from outside the class.

class User
{
    public string $name;

    public function greet(): string
    {
        return "Hello";
    }
}

Usage:

$user = new User();

$user->name = "John";

echo $user->greet();

---

Protected Properties and Methods

protected members can be accessed within the class and its child classes.

class User
{
    protected string $role = "user";

    protected function getRole(): string
    {
        return $this->role;
    }
}

The property cannot normally be accessed directly from outside the class.

---

Private Properties and Methods

private members can only be accessed within the class that defines them.

class BankAccount
{
    private float $balance = 0;

    public function deposit(
        float $amount
    ): void {
        $this->balance += $amount;
    }
}

Outside code cannot directly modify:

$account->balance;

This provides an important level of encapsulation.

---

Public vs Protected vs Private

Modifier	Same Class	Child Class	Outside Class
public	Yes	Yes	Yes
protected	Yes	Yes	No
private	Yes	No	No

A common approach is to keep internal implementation details private or protected and expose only the operations that users of the class actually need.

---

Encapsulation in PHP

Encapsulation means keeping an object’s internal state controlled and exposing only appropriate ways to interact with it.

Consider a bank account.

Bad design:

class BankAccount
{
    public float $balance;
}

Anyone can potentially do:

$account->balance = -500000;

A better design:

class BankAccount
{
    private float $balance = 0;

    public function deposit(
        float $amount
    ): void {
        if ($amount <= 0) {
            throw new InvalidArgumentException(
                "Amount must be positive."
            );
        }

        $this->balance += $amount;
    }

    public function getBalance(): float
    {
        return $this->balance;
    }
}

Now the class controls how the balance changes.

---

Getters and Setters

Getters retrieve values.

Setters modify values.

Example:

class User
{
    private string $name;

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

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

Usage:

$user = new User();

$user->setName("John");

echo $user->getName();

However, don’t automatically create getters and setters for every property.

If a property should not be modified after creation, consider making it readonly or exposing only the operations that make sense.

---

Readonly Properties in PHP

Modern PHP supports readonly properties.

For example:

class User
{
    public function __construct(
        public readonly int $id,
        public string $name
    ) {
    }
}

The id cannot be changed after initialization.

$user = new User(
    10,
    "John"
);

This can be useful for values that should remain immutable after object creation.

---

Static Properties

Static properties belong to the class rather than a specific object.

Example:

class Counter
{
    public static int $count = 0;

    public function __construct()
    {
        self::$count++;
    }
}

Create multiple objects:

new Counter();
new Counter();
new Counter();

echo Counter::$count;

Output:

3

---

Static Methods

Static methods can be called without creating an object.

Example:

class MathHelper
{
    public static function square(
        int $number
    ): int {
        return $number * $number;
    }
}

Call it:

echo MathHelper::square(5);

Output:

25

Static methods are useful for genuinely stateless utility operations, but they shouldn’t be used everywhere.

---

self vs $this

These two are commonly confused.

$this

Refers to the current object.

$this->name;

self

Refers to the current class.

self::$count;

Example:

class Example
{
    public string $name = "John";

    public static int $count = 0;

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

    public static function showCount(): int
    {
        return self::$count;
    }
}

---

Inheritance in PHP

Inheritance allows one class to inherit functionality from another class.

Example:

class Animal
{
    public function eat(): string
    {
        return "Eating...";
    }
}

class Dog extends Animal
{
    public function bark(): string
    {
        return "Woof!";
    }
}

Now:

$dog = new Dog();

echo $dog->eat();
echo $dog->bark();

The Dog class inherits the eat() method from Animal.

---

Parent and Child Classes

The relationship can be visualized as:

              Animal
                 │
        ┌────────┴────────┐
        ↓                 ↓
       Dog               Cat
        │                 │
      bark()            meow()

Both Dog and Cat inherit common functionality from Animal.

This is useful when multiple classes share common behavior.

---

Method Overriding

A child class can override a method inherited from its parent.

Example:

class Animal
{
    public function sound(): string
    {
        return "Some sound";
    }
}

class Dog extends Animal
{
    public function sound(): string
    {
        return "Woof!";
    }
}

Now:

$dog = new Dog();

echo $dog->sound();

Output:

Woof!

---

Calling the Parent Method

You can use:

parent::

to call a method from the parent class.

Example:

class Animal
{
    public function sound(): string
    {
        return "Animal sound";
    }
}

class Dog extends Animal
{
    public function sound(): string
    {
        return parent::sound() . " - Woof!";
    }
}

---

Abstract Classes

An abstract class cannot normally be instantiated directly.

It is designed to provide a common structure for child classes.

Example:

abstract class Payment
{
    abstract public function pay(
        float $amount
    ): bool;
}

A child class must implement the abstract method:

class StripePayment extends Payment
{
    public function pay(
        float $amount
    ): bool {
        // Payment logic
        return true;
    }
}

This is useful when multiple implementations share a common contract.

---

Interfaces in PHP

An interface defines a contract that classes must follow.

Example:

interface PaymentGateway
{
    public function pay(
        float $amount
    ): bool;
}

A class implements the interface:

class StripeGateway implements PaymentGateway
{
    public function pay(
        float $amount
    ): bool {
        return true;
    }
}

Another implementation can follow the same contract:

class PayPalGateway implements PaymentGateway
{
    public function pay(
        float $amount
    ): bool {
        return true;
    }
}

This makes it easier to switch implementations.

---

Abstract Class vs Interface

Feature	Abstract Class	Interface
Can contain implemented methods	Yes	Yes, depending on language features
Can contain properties	Yes	Limited compared with classes
Multiple inheritance	No	A class can implement multiple interfaces
Main purpose	Shared base behavior	Contract
Keyword	extends	implements

A simple rule:

Use an interface when you primarily need a contract. Use an abstract class when you need a shared base implementation.

---

Traits in PHP

Traits allow developers to reuse methods across unrelated classes.

Example:

trait Loggable
{
    public function log(
        string $message
    ): void {
        echo $message;
    }
}

Use the trait:

class Order
{
    use Loggable;
}

class User
{
    use Loggable;
}

Now both classes can use:

$order->log("Order created");

$user->log("User registered");

Traits are useful when functionality doesn’t naturally belong to a single inheritance hierarchy.

---

Composition vs Inheritance

Not every relationship should use inheritance.

Suppose an order needs a payment service.

Instead of:

Order extends Payment

a better relationship may be:

Order
  │
  └── PaymentService

This is composition.

Example:

class PaymentService
{
    public function charge(
        float $amount
    ): bool {
        return true;
    }
}

class OrderService
{
    public function __construct(
        private PaymentService $payment
    ) {
    }

    public function checkout(
        float $amount
    ): bool {
        return $this->payment->charge($amount);
    }
}

Composition often produces more flexible and maintainable systems.

---

Real-World Example: User Class

Let’s create a simple user class.

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

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

    public function getEmail(): string
    {
        return $this->email;
    }

    public function greet(): string
    {
        return "Hello, {$this->name}!";
    }
}

Create an object:

$user = new User(
    "John",
    "john@example.com"
);

echo $user->greet();

Output:

Hello, John!

The class keeps its internal properties private while exposing useful methods.

---

Real-World Example: Product Class

Consider an e-commerce product.

class Product
{
    public function __construct(
        private string $name,
        private float $price
    ) {
    }

    public function getPrice(): float
    {
        return $this->price;
    }

    public function applyDiscount(
        float $percentage
    ): void {
        $this->price -=
            $this->price * ($percentage / 100);
    }
}

Usage:

$product = new Product(
    "Laptop",
    1000
);

$product->applyDiscount(10);

echo $product->getPrice();

Output:

900

The object manages its own state and behavior.

---

Real-World Example: Payment Gateway

Interfaces become particularly useful for payment systems.

interface PaymentGateway
{
    public function charge(
        float $amount
    ): bool;
}

Implementation:

class StripeGateway implements PaymentGateway
{
    public function charge(
        float $amount
    ): bool {
        // Stripe API integration
        return true;
    }
}

Another implementation:

class PayPalGateway implements PaymentGateway
{
    public function charge(
        float $amount
    ): bool {
        // PayPal API integration
        return true;
    }
}

Now the business logic can depend on the interface instead of a specific provider.

              PaymentGateway
                    │
          ┌─────────┴─────────┐
          ↓                   ↓
   StripeGateway        PayPalGateway

This design makes the application easier to extend.

---

Dependency Injection With PHP Classes

Modern PHP applications frequently use dependency injection.

Example:

class OrderService
{
    public function __construct(
        private PaymentGateway $gateway
    ) {
    }

    public function checkout(
        float $amount
    ): bool {
        return $this->gateway->charge($amount);
    }
}

Now you can provide any implementation of PaymentGateway.

$gateway = new StripeGateway();

$orderService = new OrderService(
    $gateway
);

This reduces tight coupling.

Frameworks such as Laravel make dependency injection especially convenient.

---

PHP Classes and Objects in Laravel

Laravel is heavily based on PHP OOP.

When working with Laravel, you’ll frequently encounter:

Models
Controllers
Services
Requests
Resources
Policies
Events
Jobs
Notifications
Middleware
Repositories
Commands

These are generally represented as PHP classes.

For example:

class ProductService
{
    public function createProduct(
        array $data
    ): Product {
        return Product::create($data);
    }
}

Understanding PHP classes and objects is therefore essential for becoming productive with Laravel.

---

Object-Oriented Programming Principles

PHP OOP is commonly described using four major principles:

                OOP
                 │
     ┌───────────┼───────────┐
     ↓           ↓           ↓
Encapsulation  Inheritance  Polymorphism
                 │
                 ↓
            Abstraction

Let’s briefly understand each.

---

1. Encapsulation

Keep internal state controlled.

private float $balance;

Expose controlled methods:

public function deposit(
    float $amount
): void {
    // ...
}

---

2. Inheritance

Reuse behavior from a parent class.

class Dog extends Animal
{
}

---

3. Polymorphism

Different classes can implement the same interface differently.

interface Notification
{
    public function send(): bool;
}

Then:

class EmailNotification implements Notification
{
    public function send(): bool
    {
        return true;
    }
}

and:

class SmsNotification implements Notification
{
    public function send(): bool
    {
        return true;
    }
}

Both satisfy the same contract.

---

4. Abstraction

Hide unnecessary implementation details and expose what the consumer needs.

For example:

interface PaymentGateway
{
    public function charge(
        float $amount
    ): bool;
}

The calling code doesn’t need to know every internal detail of the payment provider.

---

PHP Classes and Objects Best Practices

Use Strong Types

Prefer:

public function calculate(
    float $price
): float

over:

public function calculate($price)

when the expected type is known.

---

Keep Properties Private When Appropriate

Instead of:

public float $balance;

consider:

private float $balance;

and expose controlled operations.

---

Keep Classes Focused

A class should have a clear responsibility.

Avoid creating a class that handles:

Users
Payments
Emails
Orders
Reports
File Uploads

all in one place.

---

Prefer Composition When Appropriate

Instead of building large inheritance hierarchies, consider injecting smaller services into classes.

---

Use Interfaces for Replaceable Implementations

For example:

PaymentGateway

can have:

StripeGateway
PayPalGateway
RazorpayGateway

implementations.

---

Avoid Excessive Static Methods

Static methods can be convenient, but overusing them can make applications harder to test and extend.

Prefer objects and dependency injection when behavior depends on external services or state.

---

Common PHP OOP Mistakes

Mistake 1: Making Everything Public

Avoid exposing internal state unnecessarily.

---

Mistake 2: Creating Huge Classes

A class with thousands of lines is often a sign that responsibilities should be separated.

---

Mistake 3: Using Inheritance Everywhere

Inheritance isn’t always the best way to reuse code.

Consider composition.

---

Mistake 4: Ignoring Type Declarations

Modern PHP provides powerful type features. Use them.

---

Mistake 5: Creating Getters and Setters for Everything

Encapsulation isn’t simply about generating methods for every property.

Expose behavior that makes sense for the object.

---

Mistake 6: Using Static Methods for Business Logic

Heavy use of static methods can create tight coupling and make testing more difficult.

---

PHP Classes and Objects: Quick Reference

Concept	Example
Class	class User {}
Object	new User()
Property	$name
Method	login()
Constructor	__construct()
Destructor	__destruct()
Current object	$this
Current class	self
Inheritance	extends
Interface	interface
Implementation	implements
Trait	trait / use
Visibility	public, protected, private
Static	static
Abstract class	abstract class
Readonly property	readonly

---

Frequently Asked Questions

1. What is a class in PHP?

A PHP class is a blueprint that defines the properties and methods an object can have.

For example:

class User
{
    public string $name;

    public function login(): bool
    {
        return true;
    }
}

---

2. What is an object in PHP?

An object is an instance of a class created using the new keyword.

$user = new User();

The object can then use the properties and methods defined by the class.

---

3. What is the difference between a class and an object in PHP?

A class is a blueprint, while an object is an actual instance created from that blueprint.

For example, Car can be a class, while a specific Toyota or BMW created from that class is an object.

---

4. What does $this mean in PHP?

$this refers to the current object inside a class.

For example:

$this->name

refers to the name property of the current object.

---

5. What is a constructor in PHP?

A constructor is a special method called automatically when an object is created.

PHP constructors use:

__construct()

They are commonly used to initialize object properties and dependencies.

---

6. What are public, protected, and private in PHP?

They are visibility modifiers.

• public members can be accessed from anywhere.
• protected members can be accessed within the class and child classes.
• private members can only be accessed within the class that defines them.

---

7. Why are classes and objects important in PHP?

Classes and objects help developers organize application code into reusable components.

They support important OOP concepts such as encapsulation, inheritance, abstraction, and polymorphism, making larger applications easier to maintain and extend.

---

8. Are PHP classes used in Laravel?

Yes. Laravel heavily uses PHP classes for controllers, models, services, middleware, requests, resources, jobs, events, policies, commands, and many other application components.

A strong understanding of PHP OOP is therefore extremely useful for Laravel development.

---

Conclusion

PHP classes and objects are the foundation of modern object-oriented PHP development.

A class provides the blueprint:

class User
{
    // Properties
    // Methods
}

An object is created from that blueprint:

$user = new User();

From there, PHP provides powerful OOP features such as:

• Properties
• Methods
• Constructors
• Visibility modifiers
• Encapsulation
• Inheritance
• Interfaces
• Abstract classes
• Traits
• Static members
• Dependency injection
• Polymorphism

These features allow developers to build applications that are easier to organize, test, maintain, and extend.

For beginners, the most important concepts to master first are classes, objects, properties, methods, constructors, $this, and visibility. Once these become comfortable, move on to inheritance, interfaces, abstraction, composition, and dependency injection.

If you’re planning to work with frameworks such as Laravel, understanding PHP OOP isn’t optional—it is one of the core skills you’ll use throughout the framework.

The goal isn’t simply to put every function inside a class. Good object-oriented PHP is about creating well-structured objects with clear responsibilities and predictable behavior.

Start with simple classes, practice with real-world examples such as users, products, orders, and payments, and gradually introduce more advanced OOP concepts as your applications become more complex.