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.
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
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.
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:
2016
Nota: Prima di PHP 7.1, gli argomenti non vengono valutati se non esiste una funzione costruttore definita.
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à:
42
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
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
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
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
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.