How do classes and objects work in PHP?

Question

Accepted Answer

PHP has full **object-oriented programming** support: classes define structure and behavior, objects are instances. Modern PHP OOP is clean and feature-rich, with visibility modifiers, constructors, and conveniences like constructor property promotion.

## Defining a class

```php
<?php
class User {
    public string $name;            // typed property
    private int $age;                // visibility: public / private / protected

public function __construct(string $name, int $age) {   // constructor
        $this->name = $name;          // $this refers to the instance; -> accesses members
        $this->age = $age;
    }

public function greet(): string {
        return "Hi, I'm {$this->name}";
    }
}

$user = new User("Ann", 30);     // create an instance
echo $user->name;                 // access a property
echo $user->greet();              // call a method
```

Classes have **typed properties**, a `__construct` method, and methods. `$this` refers to the current object, and `->` accesses properties/methods (PHP uses `->`, not `.`).

## Visibility modifiers (encapsulation)

```php
public    // accessible everywhere
private   // only within THIS class
protected // this class and subclasses
```

## Constructor property promotion (PHP 8 — less boilerplate)

```php
class User {
    // declare AND assign properties directly in the constructor signature
    public function __construct(
        public string $name,
        private int $age = 0,
    ) {}
    // equivalent to declaring the properties + assigning them — much less code
}
```

PHP 8's **constructor property promotion** eliminates the repetitive declare-then-assign boilerplate — a major modern convenience.

## Static members and constants

```php
class Counter {
    public static int $count = 0;      // belongs to the CLASS, not instances
    const MAX = 100;                    // class constant

public static function increment(): void {
        self::$count++;                  // access static via self::
    }
}
Counter::increment();                    // call via ClassName::
Counter::MAX;
```

Static members (`::` syntax) belong to the class itself; constants use `const`.

## Why it matters

Object-oriented programming is central to modern PHP — frameworks (Laravel, Symfony) and professional codebases are built around classes, so understanding PHP OOP is fundamental for any serious PHP development.

Knowing how to define classes with typed properties, constructors, and methods, the **visibility modifiers** (`public`/`private`/`protected`) that enforce encapsulation, the `$this`/`->`/`::` syntax, and static members/constants is essential everyday knowledge.

The modern conveniences are particularly worth knowing — **constructor property promotion** (PHP 8) dramatically reduces boilerplate and is widely used in current code, and **typed properties** make classes more robust.

Modern PHP OOP is clean and capable (a far cry from PHP's early procedural reputation), and since all modern PHP frameworks and applications are object-oriented, mastering classes and objects — including the PHP-specific syntax and modern features — is foundational, must-know material for writing professional PHP.