Public vs Private vs Protected in PHP Classes

By the end of this page, you will understand how visibility works in PHP classes, what public, private, and protected mean, and how to choose the right one for properties and methods. You will also see practical examples, common mistakes, and how these access levels are used in real projects.

In PHP, public, private, and protected are visibility keywords. They control where a property or method can be accessed from.

Visibility matters because classes are meant to hide internal details and expose only the parts that other code should use. This helps you:

• protect important data from accidental changes
• keep class internals flexible
• make your code easier to understand and maintain
• enforce clear boundaries between a class and the outside world

Here is the core idea:

• public: accessible from anywhere
• private: accessible only inside the same class
• protected: accessible inside the same class and its child classes

Why this matters

Imagine a class represents a bank account. You probably want other code to call a method like deposit() or withdraw(), but you do not want external code directly changing the balance in unsafe ways.

That is why visibility is useful: it lets you define a safe public interface and hide the internal implementation.

Quick definition

public

Use public for methods and properties that are intended to be used by other parts of your program.

Think of a class like a building.

• public is the front door: anyone is allowed in.
• protected is the staff-only area: the building's workers and approved branches can enter.
• private is the owner's locked office: only that exact office owner can access it.

Another way to think about it:

• public = what the class promises to the outside world
• private = how the class works internally
• protected = internal tools that subclasses are allowed to reuse

This mental model helps with design:

• If outside code should use it directly, make it public.
• If it is an implementation detail, make it private.
• If subclasses need it but outside code should not, make it protected.

Basic syntax

class Example {
    public string $publicProperty = 'visible everywhere';
    protected string $protectedProperty = 'visible in class and subclasses';
    private string $privateProperty = 'visible only in this class';

    public function publicMethod(): void {
        echo "Public method\n";
    }

    protected function protectedMethod(): void {
        echo "Protected method\n";
    }

    private function privateMethod(): void {
        echo "Private method\n";
    }
}

Example: safe class design

class  {
       = ;

     {
         ( > ) {
            ->balance += ;
        }
    }

     {
         ->balance;
    }
}

 =  ();
->();
 ->(); 

Consider this example:

class Counter {
    private int $count = 0;

    public function increment(): void {
        $this->count++;
    }

    public function getCount(): int {
        return $this->count;
    }
}

$counter = new Counter();
$counter->increment();
$counter->increment();
echo $counter->getCount();

Step by step

1. The class is defined

Counter has:

• a private property $count
• a public method increment()
• a public method

1. Protecting data in domain objects

In an e-commerce app, an Order class may store internal state such as total price, status, or discount calculations.

class Order {
    private float $total = 0;

    public function addItem(float $price): void {
        $this->total += $price;
    }

    public function getTotal(): float {
        return $this->total;
    }
}

This prevents outside code from doing something unsafe like:

// Not allowed if $total is private
$order->total = -500;

2. Creating a clean public API

Libraries often expose only a few public methods and keep helper logic private.

In real projects, visibility is used to separate a class into two parts:

• public API: what other code is allowed to call
• internal implementation: helper methods and internal state

Common patterns

Guarding internal state

Developers often make properties private and expose public getter/setter methods only when needed.

class Product {
    private float $price;

    public function setPrice(float $price): void {
        if ($price < 0) {
            throw new InvalidArgumentException('Price cannot be negative');
        }

        $this->price = $price;
    }

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

1. Making everything public

Beginners often mark all properties and methods as public.

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

Why this is a problem

• outside code can change anything at any time
• validation becomes harder
• internal structure becomes part of the public contract

Better approach

class User {
    private string $email;
    private string $password;

    public function setEmail(string $email): void {
        $this->email = $email;
    }

    public function getEmail():  {
         ->email;
    }
}

Visibility comparison

private vs protected

Quick rules

• public = accessible everywhere
• protected = accessible in the class and subclasses
• private = accessible only in the same class

Access table

Syntax

class Example {
    public $a;
    protected ;
     ;

     {}
     {}
     {}
}

What does public mean in PHP?

public means a property or method can be accessed from anywhere: inside the class, from child classes, and from outside objects.

What does private mean in PHP?

private means only the same class can access that property or method directly.

What does protected mean in PHP?

protected means the current class and its child classes can access it, but outside code cannot.

Should class properties be private in PHP?

Usually, yes. Making properties private helps protect data and lets you control access through methods.

Can a child class access private properties in PHP?

No. A child class cannot directly access a parent's private properties or methods.

When should I use protected instead of private?

Use protected when subclasses genuinely need access to a property or method. Otherwise, prefer private.

Is it bad to make everything public?

In most cases, yes. It exposes internal details, makes validation harder, and increases coupling between parts of your code.

Can protected members be accessed outside the class?

Encapsulation

Encapsulation is the broader object-oriented idea behind visibility. It means hiding internal details and exposing a controlled interface.

Classes and objects

Visibility only makes sense inside classes, so understanding how objects are created and used is foundational.

Inheritance

protected is especially relevant when one class extends another.

Methods and properties

Visibility applies to both methods and properties, so these concepts are directly connected.

Getters and setters

These are common ways to safely expose private properties.

Constructor

Constructors often initialize private or protected properties when an object is created.

Abstract classes

Abstract base classes often use protected members to share behavior with subclasses.

Interfaces

Interfaces define public behavior contracts, which complements the idea of controlling what is exposed.