PHP Class and Object: Properties, Methods and $this

A PHP class is declared with class Name { ... } and holds properties (variables) and methods (functions). new Name() creates an object from it, and -> reads a property or calls a method: $user->name, $user->greet().

<?php
class User
{
    public string $name = 'Guest';

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

$user = new User();
echo $user->greet(), "\n";

$user->name = 'Ada';
echo $user->greet(), "\n";

The class is the blueprint, the object is one thing built from it. You can create as many objects from one class as you need, and each has its own property values.

Properties and methods

A property is declared with a visibility keyword, an optional type and an optional default value. A method is a function inside the class. Inside a method, $this is the object the method was called on, so $this->balance reads that object's balance.

<?php
class Account
{
    public string $owner = '';
    public float $balance = 0;

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

    public function summary(): string
    {
        return sprintf('%s has %.2f', $this->owner, $this->balance);
    }
}

$a = new Account();
$a->owner = 'Ada';
$a->deposit(50);
$a->deposit(25.5);

$b = new Account();
$b->owner = 'Linus';
$b->deposit(10);

echo $a->summary(), "\n";
echo $b->summary(), "\n";

Each object keeps its own $balance: depositing into $a does not touch $b. Setting properties one by one after new gets tedious; a constructor takes the starting values as arguments instead.

public, private and protected

Visibility controls who can touch a property or call a method:

Making a property private and exposing methods is how a class protects its own rules. Here the balance can only change through deposit() and withdraw(), which refuse bad amounts:

<?php
class Wallet
{
    private int $cents = 0;

    public function deposit(int $cents): void
    {
        if ($cents <= 0) {
            throw new InvalidArgumentException('Deposit must be positive');
        }
        $this->cents += $cents;
    }

    public function withdraw(int $cents): bool
    {
        if ($cents > $this->cents) {
            return false;
        }
        $this->cents -= $cents;
        return true;
    }

    public function balance(): int
    {
        return $this->cents;
    }
}

$w = new Wallet();
$w->deposit(500);
var_dump($w->withdraw(800));
var_dump($w->withdraw(200));
echo $w->balance(), "\n";

Reading the private property from outside the class is not a warning, it is an Error:

<?php
// This throws an Error on purpose: $cents is private
class Wallet
{
    private int $cents = 500;
}

$w = new Wallet();
echo $w->cents;

Typed properties and uninitialized values

A typed property without a default value starts out uninitialized, which is different from null. Reading it before anything is assigned throws an Error. Either give it a default, assign it in the constructor, or make it nullable with ?Type and = null.

<?php
class Product
{
    public string $name;           // no default: uninitialized
    public ?string $sku = null;    // nullable with a default
    public int $stock = 0;
}

$p = new Product();
var_dump($p->sku, $p->stock);

try {
    echo $p->name;
} catch (Error $e) {
    echo $e->getMessage(), "\n";
}

$p->name = 'Keyboard';
echo $p->name, "\n";

Types are enforced on assignment. With the default (non-strict) mode, $p->stock = '7' converts the numeric string to 7, while $p->stock = 'many' throws a TypeError.

readonly properties

A readonly property (PHP 8.1) can be written once, from inside the class, and then never again. It is the usual way to build value objects such as money amounts or IDs. PHP 8.2 added readonly class, which makes every property readonly.

<?php
class Order
{
    public readonly string $id;

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

$order = new Order('A-1001');
echo $order->id, "\n";

try {
    $order->id = 'B-2002';
} catch (Error $e) {
    echo $e->getMessage(), "\n";
}

A readonly property must have a type, and it cannot have a default value. If you need a changed copy, create a new object (new Order('B-2002')) instead of editing the old one.

Print an object with __toString

echo $object only works when the class defines __toString(). The method returns the string PHP should use whenever the object is treated as text: in echo, in string concatenation, in "{$object}".

<?php
class Money
{
    public function __construct(
        private int $cents,
        private string $currency = 'EUR',
    ) {}

    public function __toString(): string
    {
        return number_format($this->cents / 100, 2) . ' ' . $this->currency;
    }
}

$price = new Money(129900);
echo $price, "\n";
echo 'Total: ' . $price . "\n";
echo "Shipping: " . new Money(450, 'USD') . "\n";

// For debugging, print_r and var_dump show the properties
print_r(new Money(5));

Without __toString, echo $object throws an Error ("Object of class Money could not be converted to string"). For debugging, print_r() and var_dump() work on any object and show private properties too; see var_dump and print_r.

Assigning an object does not copy it

This is the mistake that bites most people coming from arrays. Assigning an array copies it. Assigning an object copies only the handle: both variables then point to the same object.

<?php
class Point
{
    public int $x = 0;
    public int $y = 0;
}

$a = new Point();
$b = $a;          // same object
$b->x = 10;
echo "a->x = {$a->x}\n";

$c = clone $a;    // independent copy
$c->x = 99;
echo "a->x = {$a->x}, c->x = {$c->x}\n";

var_dump($a === $b, $a === $c, $a == $c);
var_dump($a instanceof Point);
echo get_class($c), "\n";

clone makes a shallow copy: if a property holds another object, both copies still share that inner object. === is true only for the same object, while == compares the property values of two objects of the same class. Passing an object to a function works the same way as assignment, so a function can change the object it receives.