Nozioni di base

class

La definizione più semplice di una classe è composta dal termine class, seguito dal nome della classe, seguito da una coppia di parentesi graffe che racchiudono le definizioni delle proprietà e dei metodi che fanno parte della classe stessa.

Il nome della classe può essere una qualunque etichetta valida che non sia una parola riservata di PHP. Un nome di classe valido inizia con una lettera o un underscore, seguiti da lettere, numeri, o underscores. Questa regola può essere rappresentata dalla seguente espressione regolare: ^[a-zA-Z_\x80-\xff][a-zA-Z0-9_\x80-\xff]*$.

Una classe può contenere le proprie costanti, variabili (chiamate "proprietà"), e funzioni (chiamate "methods").

Example #1 Semplice definizione di una classe

<?php
class SimpleClass
{
    // dichiarazione di proprietà
    public $var = 'un valore di default';

    // dichiarazione di metodi
    public function mostraVar() {
        echo $this->var;
    }
}
?>

La pseudo-variabile $this è disponibile quando un metodo è invocato dall'interno del contesto di un oggetto. $this è il valore dell'oggetto chiamante.

Avviso

La chiamata in modo statico di un metodo non statico genera un Error. Prima di PHP 8.0.0, questo generava un avviso di deprecazione e $this non sarebbe stato definito.

Example #2 Esempi della pseudo-variabile $this

<?php
class A
{
    function foo()
    {
        if (isset($this)) {
            echo '$this è definito (';
            echo get_class($this);
            echo ")\n";
        } else {
            echo "\$this non è definito.\n";
        }
    }
}

class B
{
    function bar()
    {
        A::foo();
    }
}

$a = new A();
$a->foo();

A::foo();

$b = new B();
$b->bar();

B::bar();
?>

Output of the above example in PHP 7:

$this è definito (A)

Deprecated: Non-static method A::foo() should not be called statically in %s  on line 27
$this non è definito.

Deprecated: Non-static method A::foo() should not be called statically in %s  on line 20
$this non è definito.

Deprecated: Non-static method B::bar() should not be called statically in %s  on line 32

Deprecated: Non-static method A::foo() should not be called statically in %s  on line 20
$this non è definito.

Output of the above example in PHP 8:

$this è definito (A)

Fatal error: Uncaught Error: Non-static method A::foo() cannot be called statically in %s :27
Stack trace:
#0 {main}
  thrown in %s  on line 27

Classi readonly

A partire da PHP 8.2.0, una classe può essere marcata con il modificatore readonly. Marcando una classe come readonly si aggiungerà il modificatore readonly ad ogni proprietà dichiarata, e preverrà la creazione di proprietà dinamiche. Inoltre, è impossibile aggiungere il loro supporto utilizzando l'attributo AllowDynamicProperties. Provando ad utilizzarlo si innescherà un errore in fase di compilazione.

<?php
#[\AllowDynamicProperties]
readonly class Foo {
}

// Fatal error: Cannot apply #[AllowDynamicProperties] to readonly class Foo
?>

Poiché né le proprietà non tipizzate né quelle statiche possono essere contrassegnate con il modificatore readonly, le classi readonly non possono dichiarare nemmeno loro:

<?php
readonly class Foo
{
    public $bar;
}

// Fatal error: Readonly property Foo::$bar must have type
?>

<?php
readonly class Foo
{
    public static int $bar;
}

// Fatal error: Readonly class Foo cannot declare static properties
?>

Una classe readonly può essere estesa se, e solo se, la classe figlia è anche una classe readonly.

new

Per creare un'istanza di una classe, deve essere usata la parola chiave new. Un oggetto sarà sempre creato a meno che la classe abbia un costruttore definito il quale sollevi un' eccezione in caso di errore. Le classi dovrebbero essere definite prima dell'istanziazione (in alcuni casi questo è un requisito).

Se viene usata una stringa contenente il nome di una classe con new, verrà creata una nuova istanza di quella classe. Se la classe appartiene ad un namespace, deve essere utilizzato il suo nome completamente qualificato.

Nota:
Se non ci sono argomenti da passare al costruttore della classe, le parentesi dopo il nome della classe possono essere omesse.

Example #3 Creazione di un'istanza

<?php
$instance = new SimpleClass();

// è anche possibile istanziare una classe il cui nome sia contenuto in una variabile:
$className = 'SimpleClass';
$instance = new $className(); // new SimpleClass()
?>

Da PHP 8.0.0, l'utilizzo di new con espressioni arbitrarie è supportato. Ciò consente istanziazioni più complesse se l'espressione produce una stringa. Le espressioni devono essere racchiuse tra parentesi.

Example #4 Creazione di un'istanza utilizzando un'espressione arbitraria

Nell'esempio fornito mostriamo più esempi di espressioni arbitrarie valide che producono un nome di classe. Questo mostra una chiamata a una funzione, la concatenazione di stringhe e la costante ::class.

<?php

class ClassA extends \stdClass {}
class ClassB extends \stdClass {}
class ClassC extends ClassB {}
class ClassD extends ClassA {}

function getSomeClass(): string
{
    return 'ClassA';
}

var_dump(new (getSomeClass()));
var_dump(new ('Class' . 'B'));
var_dump(new ('Class' . 'C'));
var_dump(new (ClassD::class));
?>

Output of the above example in PHP 8:

object(ClassA)#1 (0) {
}
object(ClassB)#1 (0) {
}
object(ClassC)#1 (0) {
}
object(ClassD)#1 (0) {
}

Nel contesto di una classe, è possibile creare un nuovo oggetto con le espressioni new self e new parent.

Quando si assegna un'istanza già creata ad una nuova variabile, la nuova variabile farà riferimento alla stessa istanza cui fa riferimento la variabile originale. Questo stesso comportamento si ha quando vengono passate istanze ad una funzione. Si può ottenere una copia di un oggetto già creato per mezzo della clonazione.

Example #5 Assegnazione di oggetti

<?php

$instance = new SimpleClass();

$assigned   =  $instance;
$reference  =& $instance;

$istance->var = '$assigned avrà questo valore';

$instance = null; // $instance e $reference diventano null

var_dump($instance);
var_dump($reference);
var_dump($assigned);
?>

Il precedente esempio visualizzerà:

NULL
NULL
object(SimpleClass)#1 (1) {
   ["var"]=>
     string(30) "$assigned avrà questo valore"
}

È possibile creare istanze di un oggetto in due modi:

Example #6 Creazione di nuovi oggetti

<?php
class Test
{
    static public function getNew()
    {
        return new static;
    }
}

class Child extends Test
{}

$obj1 = new Test();
$obj2 = new $obj1;
var_dump($obj1 !== $obj2);

$obj3 = Test::getNew();
var_dump($obj3 instanceof Test);

$obj4 = Child::getNew();
var_dump($obj4 instanceof Child);
?>

Il precedente esempio visualizzerà:

bool(true)
bool(true)
bool(true)

È possibile accedere ad un membro di un oggetto appena creato in una singola espressione:

Example #7 Accesso al membro dell'oggetto appena creato

<?php
echo (new DateTime())->format('Y');
?>

Il precedente esempio visualizzerà qualcosa simile a:

Nota: Prima di PHP 7.1, gli argomenti non vengono valutati se non esiste una funzione costruttore definita.

Proprietà e metodi

Le proprietà e i metodi della classe vivono in "namespace" separati, quindi è possibile avere una proprietà ed un metodo con lo stesso nome. Dato che sia una proprietà che un metodo hanno la stessa notazione, e la scelta se verrà letta la proprietà o se verrà chiamato il metodo, dipende solo dal contesto, per esempio se l'uso è un accesso ad una variabile o una chiamata ad una funzione.

Example #8 Accesso alla proprietà vs. chiamata del metodo

<?php
class Foo
{
    public $bar = 'property';
    
    public function bar() {
        return 'method';
    }
}

$obj = new Foo();
echo $obj->bar, PHP_EOL, $obj->bar(), PHP_EOL;

Il precedente esempio visualizzerà:

property
method

Ciò significa che chiamare una funzione anonima che è stata assegnata ad una proprietà non è direttamente possibile. Per esempio, la proprietà deve essere assegnata prima ad una variabile. È possibile chiamare questo tipo di proprietà direttamente racchiudendola tra parentesi.

Example #9 Chiamare una funzione anonima memorizzata in una proprietà

<?php
class Foo
{
    public $bar;
    
    public function __construct() {
        $this->bar = function() {
            return 42;
        };
    }
}

$obj = new Foo();

echo ($obj->bar)(), PHP_EOL;

Il precedente esempio visualizzerà:

extends

Una classe può ereditare le costanti, i metodi e le proprietà di un'altra classe utilizzando la parola chiave extends nella dichiarazione della classe. Non è possibile estendere più di una classe per volta; ogni classe può ereditare da una sola altra classe.

Le costanti, i metodi e le proprietà ereditate possono essere sovrascritte ridichiarandole nella nuova classe con lo stesso nome definito nella classe padre. Questo non sarà comunque possibile se il metodo o la costante che si intende ridefinire è stato dichiarato nella classe padre come final. Si può accedere alle proprietà statiche e ai metodi ridefiniti riferendosi ad essi con parent::.

Nota: A partire da PHP 8.1.0, le costanti possono essere dichiarate come final.

Example #10 Ereditarietà semplice

<?php
class ExtendClass extends SimpleClass
{
    // Ridefinisce il metodo presente in ClasseSemplice
    function displayVar()
    {
        echo "Classe figlia\n";
        parent::displayVar();
    }
}

$extended = new ExtendClass();
$extended->displayVar();
?>

Il precedente esempio visualizzerà:

Classe figlia
un valore di default

Regole di compatibilità della firma

Quando si sovrascrive un metodo, la sua firma deve essere compatibile con il metodo padre. Altrimenti, viene emesso un errore fatale o, prima di PHP 8.0.0, viene generato un errore di livello E_WARNING. Una firma è compatibile se rispetta le regole di varianza, rende facoltativo un parametro obbligatorio e se i nuovi parametri sono opzionali. Questo è noto come Principio di Sostituzione di Liskov, o LSP in breve. I metodi costruttore e privati sono esenti da queste regole di compatibilità della firma e quindi non genereranno un errore fatale nel caso di una mancata corrispondenza della firma.

Example #11 Metodi figli compatibili

<?php

class Base
{
    public function foo(int $a) {
        echo "Valido\n";
    }
}

class Extend1 extends Base
{
    function foo(int $a = 5)
    {
        parent::foo($a);
    }
}

class Extend2 extends Base
{
    function foo(int $a, $b = 5)
    {
        parent::foo($a);
    }
}

$extended1 = new Extend1();
$extended1->foo();
$extended2 = new Extend2();
$extended2->foo(1);

Il precedente esempio visualizzerà:

Valido
Valido

I seguenti esempi dimostrano che un metodo figlio che rimuove un parametro o rende obbligatorio un parametro facoltativo non è compatibile con il metodo padre.

Example #12 Errore fatale quando un metodo figlio rimuove un parametro

<?php

class Base
{
    public function foo(int $a = 5) {
        echo "Valido\n";
    }
}

class Extend extends Base
{
    function foo()
    {
        parent::foo(1);
    }
}

Output of the above example in PHP 8 is similar to:

Fatal error: Declaration of Extend::foo() must be compatible with Base::foo(int $a = 5) in /in/evtlq on line 13

Example #13 Errore fatale quando un metodo figlio rende obbligatorio un parametro facoltativo

<?php

class Base
{
    public function foo(int $a = 5) {
        echo "Valido\n";
    }
}

class Extend extends Base
{
    function foo(int $a)
    {
        parent::foo($a);
    }
}

Output of the above example in PHP 8 is similar to:

Fatal error: Declaration of Extend::foo(int $a) must be compatible with Base::foo(int $a = 5) in /in/qJXVC on line 13

Avviso

Rinominare il parametro di un metodo in una classe figlia non è un'incompatibilità di firma. Tuttavia, questo è sconsigliato poiché risulterà in un Errore di runtime se vengono utilizzati gli argomenti con nome.

Example #14 Errore durante l'utilizzo di argomenti e parametri con nome rinominati in una classe figlia

<?php

class A {
    public function test($foo, $bar) {}
}

class B extends A {
    public function test($a, $b) {}
}

$obj = new B;

// Passa i parametri in base al contratto A::test()
$obj->test(foo: "foo", bar: "bar"); // ERRORE!

Il precedente esempio visualizzerà qualcosa simile a:

Fatal error: Uncaught Error: Unknown named parameter $foo in /in/XaaeN:14
Stack trace:
#0 {main}
  thrown in /in/XaaeN on line 14

::class

La parola chiave class è anche usata per la risoluzione del nome della classe. Per ottenere il nome completo di una classe ClassName utilizzare ClassName::class. Questo è particolarmente utile con le classi presenti nei namespace.

Example #15 Risoluzione del nome della classe

<?php
namespace NS {
    class ClassName {
    }
    
    echo ClassName::class;
}
?>

Il precedente esempio visualizzerà:

NS\ClassName

Nota:
La risoluzione del nome della classe utilizzando ::class è una trasformazione in fase di compilazione. Ciò significa che al momento della creazione della stringa del nome della classe non è ancora stato eseguito il caricamento automatico. Di conseguenza, i nomi delle classi vengono espansi anche se la classe non esiste. In questo caso non viene emesso alcun errore.
Example #16 Risoluzione del nome della classe mancante

<?php print Does\Not\Exist::class; ?>

Il precedente esempio visualizzerà:
Does\Not\Exist

A partire da PHP 8.0.0, la costante ::class può essere utilizzata anche sugli oggetti. Questa risoluzione avviene in fase di esecuzione, non in fase di compilazione. Il suo effetto è lo stesso della chiamata di get_class() sull'oggetto.

Example #17 Risoluzione del nome dell'oggetto

<?php
namespace NS {
    class ClassName {
    }
}
$c = new ClassName();
print $c::class;
?>

Il precedente esempio visualizzerà:

NS\ClassName

Metodi e proprietà nullsafe

A partire da PHP 8.0.0, è possibile accedere alle proprietà e ai metodi anche con l'operatore "nullsafe": ?->. L'operatore nullsafe funziona allo stesso modo dell'accesso alla proprietà o al metodo come sopra, tranne per il fatto che se l' oggetto da dereferenziare è null allora null verrà restituito piuttosto che un'eccezione generata. Se la dereferenziazione fa parte di una catena, il resto della catena viene saltato.

L'effetto è simile ad effettuare prima il wrap su ogni accesso in un controllo is_null(), ma più compatto.

Example #18 L'Operatore Nullsafe

<?php

// A partire da PHP 8.0.0, questa riga:
$result = $repository?->getUser(5)?->name;

// È equivalente al seguente blocco di codice:
if (is_null($repository)) {
    $result = null;
} else {
    $user = $repository->getUser(5);
    if (is_null($user)) {
        $result = null;
    } else {
        $result = $user->name;
    }
}
?>

Nota:
L'operatore nullsafe viene utilizzato al meglio quando null è considerato un valore possibile valido e previsto per una proprietà o return di un metodo. Per indicare un errore, è preferibile un'eccezione generata.