Hoe werken klassen en objecten in PHP?

Question

IT Interview Practice · Accepted Answer

PHP heeft volledige **object-oriented programming** ondersteuning: klassen definiëren structuur en gedrag, objecten zijn instanties. Moderne PHP OOP is schoon en feature-rich, met visibility modifiers, constructors en gemakken zoals constructor property promotion.

## Een klasse definiëren

```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
```

Klassen hebben **typed properties**, een `__construct` methode en methods. `$this` verwijst naar het huidige object, en `->` geeft toegang tot properties/methods (PHP gebruikt `->`, niet `.`).

## Visibility modifiers (encapsulation)

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

## Constructor property promotion (PHP 8 — minder 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
}
```

De **constructor property promotion** van PHP 8 elimineert de repetitieve declare-then-assign boilerplate — een grote moderne gemak.

## Static members en 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) horen bij de klasse zelf; constants gebruiken `const`.

## Waarom het belangrijk is

Object-oriented programming is centraal voor moderne PHP — frameworks (Laravel, Symfony) en professionele codebases zijn gebouwd rond klassen, dus het begrijpen van PHP OOP is fundamenteel voor serieuze PHP-ontwikkeling.

Weten hoe je klassen met typed properties, constructors en methods definieert, de **visibility modifiers** (`public`/`private`/`protected`) die encapsulation afdwingen, de `$this`/`->`/`::` syntax, en static members/constants is essentiële dagelijkse kennis.

De moderne gemakken zijn bijzonder nuttig om te kennen — **constructor property promotion** (PHP 8) vermindert boilerplate dramatisch en wordt veel gebruikt in huidige code, en **typed properties** maken klassen robuuster.

Moderne PHP OOP is schoon en capabel (een wereld van verschil met PHP's vroege procedurele reputatie), en omdat alle moderne PHP frameworks en applicaties object-oriented zijn, het beheersen van klassen en objecten — inclusief de PHP-specifieke syntax en moderne features — is fundamenteel, must-know materiaal voor het schrijven van professionele PHP.

Een klasse definiëren

Visibility modifiers (encapsulation)

Constructor property promotion (PHP 8 — minder boilerplate)

Static members en constants

Waarom het belangrijk is

Gerelateerde vragen