Cum funcționează clasele și obiectele în PHP?

Question

Accepted Answer

PHP are suport complet pentru **programarea orientată pe obiecte**: clasele definesc structura și comportamentul, obiectele sunt instanțe. PHP OOP modern este curat și bogat în funcții, cu modificatori de vizibilitate, constructori și conveniențe cum ar fi promovarea proprietății constructorului.

## Definirea unei clase

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

Clasele au **proprietăți tipizate**, o metodă `__construct` și metode. `$this` se referă la obiectul actual, iar `->` accesează proprietățile/metodele (PHP folosește `->`, nu `.`).

## Modificatori de vizibilitate (încapsulare)

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

## Promovarea proprietății constructorului (PHP 8 — mai puțin 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
}
```

**Promovarea proprietății constructorului** din PHP 8 elimină boilerplate-ul repetitiv declare-then-assign — o comoditate importantă modernă.

## Membri statici și constante

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

Membrii statici (sintaxa `::`) aparțin clasei în sine; constantele folosesc `const`.

## De ce este important

Programarea orientată pe obiecte este centrală pentru PHP modern — framework-uri (Laravel, Symfony) și codebase-uri profesionale sunt construite în jurul claselor, deci înțelegerea PHP OOP este fundamentală pentru orice dezvoltare PHP serioasă.

Cunoașterea modului de definire a claselor cu proprietăți tipizate, constructori și metode, **modificatori de vizibilitate** (`public`/`private`/`protected`) care impun încapsulare, sintaxa `$this`/`->`/`::` și membri/constante statici este cunoștință esențială zilnică.

Conveniențele moderne sunt deosebit de demne de cunoscut — **promovarea proprietății constructorului** (PHP 8) reduce dramatic boilerplate-ul și este utilizată pe scară largă în codul actual, iar **proprietățile tipizate** fac clasele mai robuste.

PHP OOP modern este curat și capabil (departe de reputația procedurală timpurie a PHP), și din moment ce toate framework-urile și aplicațiile PHP moderne sunt orientate pe obiecte, stăpânirea claselor și obiectelor — inclusiv sintaxa specifică PHP și funcțiile moderne — este material fundamental și obligatoriu pentru scrierea de PHP profesional.