PHP Manual

Language Reference - Classes and Objects

Questa è sicuramente una parte importante del linguaggio. La sezione è molto vasta. Non credo che riuscirò a tradurla tutta.

Nota ci sono diverse utili funzioni per manipolare classi ed oggetti vedi:Class/Object Functions

• Introduzione
• Le basi
  • Definizione di classe
  • La parola chiave new
  • Proprietà e metodi
  • Ereditarietà - extends
  • ::class
• Le properties
• Le costanti
• Autoloading

Introduction

A partire della versione 5, il modello ad oggetti di è stato riscritto per aggiungere funzionalità ed ottenere migliori prestazioni. Il maggior cambiamento dalla versione 4 è che PHP 5 ha un modello di oggetti completo.

Fra le funzionalità incluse in PHP 5 ci sono: visbility, classi e metodi abstract e final, aggiuntivi magic methods, interfaces, cloning, e typehinting

PHP tratta gli oggetti allo stesso modo dei references e degli handles, questo significa che ogni variabile contiene un reference ad oggetto piuttosto che una copia dell'intero oggetto. Vedi Objects and Refernces

Tip - Vedi anche Userland Naming Guide

Le basi

Definizione di classe

La definizione base di classe inizia con la parola chiave class, seguita dal nome della classe, seguito da una coppia di parentici graffe che racchiudono le definizioni delle proprietà e dei metodi appartenenti alla classe.

Il nome della classe può essere una qualsiasi etichetta valida ad eccezione delle parole riservate del linguaggio, reserved words. Un nome valido di classe inizia con una lettera o con un undescore, seguito da un numero qualsiasi di lettere, numeri o underscores

Una classe può contenere proprie costanti, variabili (properties) e funzioni (methods).

Esempio 1 - Una semplice definizione di classe

<?php
class ClasseSemplice{
    function __construct(){echo nl2br("Creata una istanza di ClasseSemplice\n");}
    //** __construct - La definizione di costruttore verrà data più avanti.
    // dichiarazione di property
    public $var = 'Un valore di default';

    // dichiarazione di metodo
    public function displayVar() {
        echo nl2br($this->var);
    }
}
?>

La pseudo variabile $this è disponibile quando un metodo è chiamato dall'interno del contesto di un oggetto. $this è un reference all'oggetto chiamante.

Esempio 2 - Alcuni esempi d'uso di $this.

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

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

$a = new A();

echo nl2br("\$a->foo() produce: \n");
$a->foo();

echo nl2br("A::foo() produce: \n");
A::foo();

$b = new B();
echo nl2br("\$b->bar() produce: \n");
$b->bar();

echo nl2br("\B::bar() produce: \n");
B::bar();
?>

La parola chiave new

Per creare una istanza di una classe, deve essere usata la parola chiave new. Istanziando un oggetto questi sarà sempre creato a meno che questo oggetto abbia un costruttore che lanci una exception o un errore. Le classi dovrebbero essere definite prima della loro istanziazione (in alcuni casi ciò è obbligatorio)

Se una stringa contenente il nome di una classe è usata con new, una nuova istanza di quella classe sarà creata.

Esempio 3 - Creazione di una istanza.

<?php
$instance = new ClasseSemplice();

// Questo può anche essere fatto con una variabile contenente il nome della classe:
$className = 'ClasseSemplice';
$instance = new $className(); // new ClasseSemplice()
?>

Esempio 4 - Assegnazione di oggetti.

<?php
$instance = new ClasseSemplice();

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

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

$instance = null; // $instance and $reference diventeranno nulli

echo nl2br("var_dump(\$instance) vale:\n");
var_dump($instance);
echo nl2br("\n");
echo nl2br("var_dump(\$reference) vale:\n");
var_dump($reference);
echo nl2br("\n");
echo nl2br("var_dump(\$assigned) vale:\n");
var_dump($assigned);
echo nl2br("\n");
?>

Esempio 5 - Creazione di un nuovo oggetto.

PHP 5.3.0 ha introdotto due nuovi modi per creare un oggetto.

<?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);
?>

Esempio 6 - Accesso a membri di un oggetto appena creato.

PHP 5.3.0 ha introdotto due nuovi modi per creare un oggetto.

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

Proprietà e metodi

Le proprietà e i metodi vivono in spazi dei nomi separati. Questo rende possibile avere proprietà e metodi con lo stesso nome:

Esempio 7 - Accesso ad oggetto e chiamata a metodo.

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

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

Esempio 8 - Chiamata di una funzione anonima memorizzata in una property.

La funzionalità precedente implica come non sia possibile chiamare, direttamente, una funzione anonima assegnata ad un proprietà. Occorre prima assegnare la proprietà ad una variabile.

Da PHP 7.0.0 è possibile una tale chiamata diretta racchiudendola fra parentisi.

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

$obj = new Foo2();

// as of PHP 5.3.0:
$func = $obj->bar;
echo $func(), PHP_EOL;

// alternatively, as of PHP 7.0.0:
echo ($obj->bar)(), PHP_EOL;
?>

Ereditarietà - extends

Una classe può ereditare i metodi e le proprietà di un'altra classe utilizzando la parola chiave extends nella dichiarazione di classe.

I metodi e le proprietà ereditate possono essere sovrascritte o ridichiarate. Comunque, se la classe padre ha definito un metodo come final, questo metodo non potrà essere sovrascritto. E' possibile accedere al metodo sovrascritto o ad una proprietà statica referenziando esso tramite parent::

Esempio 9 - Ereditarietà semplice.

<?php
class SempliceEstesa extends ClasseSemplice{
    // Reidevinisce il metoto displayVar() della classe padre.
    function displayVar(){
        echo "Classe SempliceEstesa\n";
        parent::displayVar();
    }
}

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

::class

Da PHP 5.5, la keyword class può essere utilizzata per la risoluzione dei nomi. Una stringa con il nome completamente qualificato della classe può essere ottenuto con ClassName::class

Esempio 10 - Risoluzione dei nomi delle classi.

<?php
echo ClasseSemplice::class;
?>

<?php
?>

Le properties

Definizione

I membri variabili delle classi sono chiamati properties. Possono essere chiamate anche "attributi" o "campi", ma in questo documente viene preferito il termine properties. Esse sono definite tramite le parole chiave, public, protected, private, seguite da una normale dichiarazione di variabile. Questa dichiarazione può includere una inizializzazione ad un valore costante che puà essere valutato al tempo di compilazione.

Per maggiori informazioni sul significato di public, protected, e private vedi Visibility

Per mantenere la compatibilità con le versioni 4 e 5 di PHP sarà ancora accettato l'uso della keyword var.

All'interno di metodi di classe non statici le property possono essere accedute usando l'operatore -> (Object Operator): $this->property (dove property è il nome della propery da accedere.

Le proprietà statiche possono essere accedute usando l'operatore :: (Double Colon): self::$property

La pseudo-variabile $this è disponibile all'interno di qualsiasi metodo della classe quaando quel metodo è chiamato all'interno del contesto dell'oggetto. $this è un reference all'oggetto chiamante(normalmente l'oggetto a cui il metodo appartiene, ma potrebbe appartenere anche ad un altro oggetto, se il metodo è chiamato staticamente dal contesto di un oggetto secondario). Questa definizione non l'ho ancora capita.

Esempio 1 - Dichiarazione di property

<?php
class SimpleClass{
   // valida per PHP 5.6.0:
   public $var1 = 'hello ' . 'world';
   // valida per PHP 5.3.0:
   public $var2 = <<<EOD
hello world
EOD;
   // valida per PHP 5.6.0:
   public $var3 = 1+2;
   /* dichiarazioni non valide
   public $var4 = self::myStaticMethod();
   public $var5 = $myVar;*/

   //dichiarazioni valide
   public $var6 = myConstant;
   public $var7 = array(true, false);

   // valida per PHP 5.3.0:
   public $var8 = <<<'EOD'
hello world
EOD;
}
?>

Le costanti

E' possibile definire su base classe valori costanti immutabili. Le costanti differiscono dalle normali variabili per l'assenza del simbolo $ nella dichiarazione e nell'uso. La visibilità di default per le costanti è public.

Il valore assegnato ad una costante deve essere una espressione di tipo costante, non una variabile, non una property ne una chiamata di funzione.

Esempio 01 - Definizione ed uso di una costante.

<?php
class MyClass
{
    const C   = 'constant value';

    function showConstant() {
        echo  self::C  . "\n";
    }
}

echo MyClass::C . "\n";

$classname = "MyClass";
echo $classname::C . "\n"; // As of PHP 5.3.0

$class = new MyClass();
$class->showConstant();

echo $class::C ."\n"; // As of PHP 5.3.0
?>
            
constant value
constant value
constant value
constant value

Esempio 02 - Esempio di dati statici.

Con PHP 5.3.0 è stato aggiunto il supporto Heredoc and Nowdoc per inizializzare costanti.

<?php
class foo3 {
    // As of PHP 5.3.0
    const BAR = <<<'EOT'
bar
EOT;
    // As of PHP 5.3.0
    const BAZ = <<<EOT
baz
EOT;
}
?>
            

Esempio 03 - Esempio d'uso della costante speciale ::class

Con PHP 5.5.0 è stata resa disponibile la speciale costante ::class, che fornisce il nome pienamente qualificato (con namespace) delle classi, questo è utile per quelle classi inserite in un namespace.

<?php
namespace NomSpac {
    class bar {
    }

    echo bar::class; // NomSpac\bar
}
?>
            

Esempio 04 - Esempio di espressione costante .

Con PHP 5.6.0 è stato reso possibile fornire un espressione scalare comprendente numeri e literals nel contesto dellea definizione di una costante.

<?php
const ONE = 1;

class foo4 {
    // As of PHP 5.6.0
    const TWO = ONE * 2;
    const THREE = ONE + self::TWO;
    const SENTENCE = 'The value of THREE is '.self::THREE;
}
echo nl2br(foo4::TWO."\n");
echo nl2br(foo4::TREE."\n");
echo nl2br(foo4::SENTENCE."\n");
?>
            
2

3

The value of THREE is 3

Esempio 05 - Modificatori di visibilità per le costanti.

Con PHP 7.0.1 è stato reso possibile l'uso dei modificatori di visibilità anche per le costanti. Ma la versione del mio PHP è la 7.0.19 in cui questo non è permesso.

<?php
class foo5 {
    // As of PHP 7.1.0
    public const BAR = 'bar';
    private const BAZ = 'baz';
}
echo foo5::BAR, PHP_EOL;
echo foo5::BAZ, PHP_EOL;
?>
            

Autoloading

Molti sviluppatori scrivono un sorgente per ogni classe. Una cosa fastidiosa è dover scrivere una lunga lista di include all'inizio di ogni file php che desidera usare quelle classi.

A partire da PHP 5 questo non è più necessario.La funzione spl_autoload_register() registra un qualsiasi numero di autoloaders, abilitando le classi e le interfacce ad essere automaticamente caricate se non sono correntemente definite. La registrazione degli autoloaders da a PHP un'ultima possibilità di caricare la classe o l'interfaccia prima di cadere in errore.

Esempio 01 - Esempio di autoload

Questo esempio tenta di caricare le classi MyClass1 e MyClass02 dai file MyClass1.php e MyClass2.php

<?php
spl_autoload_register(function ($class_name) {
    include $class_name . '.php';
});

$obj  = new MyClass1();
$obj2 = new MyClass2(); 
?>

<?php
?>