Hur fungerar klasser och objekt i PHP?

Question

Accepted Answer

PHP har fullt stöd för **objektorienterad programmering**: klasser definierar struktur och beteende, objekt är instanser. Modern PHP OOP är ren och funktionsrik, med synlighetsmodifierare, konstruktörer och bekvämligheter som konstruktöregendomsbefordran.

## Definiera en klass

```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 **typad egenskaper**, en `__construct`-metod och metoder. `$this` refererar till det aktuella objektet, och `->` får åtkomst till egenskaper/metoder (PHP använder `->`, inte `.`).

## Synlighetsmodifierare (kapsling)

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

## Konstruktöregendomsbefordran (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 **konstruktöregendomsbefordran** eliminerar den repetitiva deklarera-sedan-tilldela boilerplate-koden — en stor modern bekvämlighet.

## Statiska medlemmar och 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;
```

Statiska medlemmar (`::` syntax) tillhör själva klassen; konstanter använder `const`.

## Varför det är viktigt

Objektorienterad programmering är central för modern PHP — ramverk (Laravel, Symfony) och professionella kodbaser är byggda omkring klasser, så att förstå PHP OOP är grundläggande för all seriös PHP-utveckling.

Att veta hur man definierar klasser med typad egenskaper, konstruktörer och metoder, **synlighetsmodifierarna** (`public`/`private`/`protected`) som tillämpar kapsling, syntaxen `$this`/`->`/`::` och statiska medlemmar/konstanter är väsentlig daglig kunskap.

De moderna bekvämlighetsåtgärderna är särskilt värda att känna till — **konstruktöregendomsbefordran** (PHP 8) minskar drastiskt boilerplate-koden och används ofta i aktuell kod, och **typad egenskaper** gör klasser mer robusta.

Modern PHP OOP är ren och kapabel (långt bort från PHPs tidiga procedurella rykte), och eftersom alla moderna PHP-ramverk och applikationer är objektorienterade, är det att bemästra klasser och objekt — inklusive PHP-specifik syntax och moderna funktioner — grundläggande, måste-kunna-material för att skriva professionell PHP.