Hvordan fungerer klasser og objekter i PHP?

Question

Accepted Answer

PHP har fuld **objektorienteret programmering** support: klasser definerer struktur og adfærd, objekter er instanser. Moderne PHP OOP er rent og feature-rigt, med synligheds-modifikatorer, konstruktører og bekvemmeligheder som konstruktor property promotion.

## Definering af 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 **typede egenskaber**, en `__construct` metode og metoder. `$this` refererer til det aktuelle objekt, og `->` tilgår egenskaber/metoder (PHP bruger `->`, ikke `.`).

## Synligheds-modifikatorer (indkapsling)

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

## Konstruktor 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 8's **konstruktor property promotion** eliminerer gentagen erklær-så-tildel boilerplate — en vigtig moderne bekvemmelighed.

## 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 bruger `const`.

## Hvorfor det betyder noget

Objektorienteret programmering er central for moderne PHP — frameworks (Laravel, Symfony) og professionelle kodetekster er bygget omkring klasser, så forståelse af PHP OOP er fundamental for enhver seriøs PHP-udvikling.

Viden om hvordan man definerer klasser med typede egenskaber, konstruktører og metoder, **synligheds-modifikatorer** (`public`/`private`/`protected`) som håndhæver indkapsling, `$this`/`->`/`::` syntaks og statiske medlemmer/konstanter er vigtig daglig viden.

De moderne bekvemmeligheder er særligt værd at kende — **konstruktor property promotion** (PHP 8) reducerer boilerplate dramatisk og bruges bredt i nuværende kode, og **typede egenskaber** gør klasser mere robuste.

Moderne PHP OOP er rent og dygtig (langt fra PHPs tidlige proced urale omdømme), og da alle moderne PHP frameworks og applikationer er objektorienterede, er beherskelse af klasser og objekter — herunder PHP-specifik syntaks og moderne funktioner — fundamental, must-know materiale for at skrive professionel PHP.