Hvordan fungerer klasser og objekter i PHP?

Question

Accepted Answer

PHP har full **object-oriented programming** støtte: klasser definerer struktur og oppførsel, objekter er instanser. Moderne PHP OOP er ren og funksjonsrik, med visibility modifiers, constructors, og bekvemmeligheter som constructor property promotion.

## Definere en klasse

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

Klasser har **typed properties**, en `__construct` metode, og metoder. `$this` refererer til det nåværende objektet, og `->` får tilgang til properties/metoder (PHP bruker `->`, ikke `.`).

## Visibility modifiers (innkapsling)

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

## Constructor property promotion (PHP 8 — mindre 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 8s **constructor property promotion** eliminerer den repetitive declare-then-assign boilerplate — en stor moderne bekvemmelighet.

## Statiske medlemmer og konstanter

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

Statiske medlemmer (`::` syntaks) tilhører klassen selv; konstanter bruker `const`.

## Hvorfor dette er viktig

Object-oriented programming er sentralt i moderne PHP — frameworks (Laravel, Symfony) og profesjonelle kodebaser er bygget rundt klasser, så å forstå PHP OOP er grunnleggende for seriøs PHP-utvikling.

Å vite hvordan man definerer klasser med typed properties, constructors og metoder, **visibility modifiers** (`public`/`private`/`protected`) som håndhever innkapsling, `$this`/`->`/`::` syntaksen, og statiske medlemmer/konstanter er essensielle kunnskaper fra dag til dag.

De moderne bekvemmeligheter er særlig verdt å kjenne — **constructor property promotion** (PHP 8) reduserer boilerplate dramatisk og brukes mye i dagens kode, og **typed properties** gjør klasser mer robuste.

Modern PHP OOP er ren og kraftig (langt fra PHP's tidlige prosedurale rykte), og siden all moderne PHP frameworks og applikasjoner er objektorienterte, å mestre klasser og objekter — inkludert PHP-spesifikk syntaks og moderne funksjoner — er grunnleggende, must-know materiale for å skrive profesjonell PHP.