Constructeur
PHP permet aux développeurs de déclarer des constructeurs pour
les classes. Les classes qui possèdent une méthode constructeur
appellent cette méthode à chaque création d'une nouvelle instance
de l'objet, ce qui est intéressant pour toutes les initialisations
dont l'objet a besoin avant d'être utilisé.
Note:
Les constructeurs parents ne sont pas appelés implicitement
si la classe enfant définit un constructeur. Si vous
voulez utiliser un constructeur parent, il sera nécessaire de faire
appel à parent::__construct()
depuis le constructeur enfant.
Si l'enfant ne définit pas un constructeur alors, il peut être hérité
de la classe parente, exactement de la même façon qu'une méthode le serait
(si elle n'a pas été déclarée comme privée).
Exemple #1 Constructeur lors de l'héritage
<?php
class BaseClass {
function __construct() {
print "Dans le constructeur de BaseClass\n";
}
}
class SubClass extends BaseClass {
function __construct() {
parent::__construct();
print "Dans le constructeur de SubClass\n";
}
}
class OtherSubClass extends BaseClass {
// Constructeur hérité de BaseClass
}
// Dans le constructeur de BaseClass
$obj = new BaseClass();
// Dans le constructeur de BaseClass
// Dans le constructeur de SubClass
$obj = new SubClass();
// Dans le constructeur de BaseClass
$obj = new OtherSubClass();
?>
À la différence des autres méthodes, __construct()
est exclue des règles de compatibilités des signatures
usuelles quand elle est étendue.
Les constructeurs sont des méthodes ordinaires qui sont appelées lors de
l'instanciation de leur objet correspondant. Par conséquent, ils peuvent
définir un nombre arbitraire d'arguments, qui peuvent être requis, avoir un type,
et peuvent avoir une valeur par défaut. Les arguments d'un constructeur sont appelés
en plaçant les arguments dans des parenthèses après le nom de la classe.
Exemple #2 Utiliser les arguments d'un constructeur
<?php
class Point {
protected int $x;
protected int $y;
public function __construct(int $x, int $y = 0) {
$this->x = $x;
$this->y = $y;
}
}
// Pass both parameters.
$p1 = new Point(4, 5);
// Pass only the required parameter. $y will take its default value of 0.
$p2 = new Point(4);
// With named parameters (as of PHP 8.0):
$p3 = new Point(y: 5, x: 4);
?>
Si une classe n'a pas de constructeur, ou que le constructeur n'a pas d'arguments requis,
les parenthèses peuvent être omises.
Style ancien des constructeurs
Antérieur à PHP 8.0.0, les classes dans le nom d'espace global interpréteront une
méthode qui a le même nom que la classe comme un constructeur de style ancien.
Cette syntaxe est obsolète, et résultera en une erreur E_DEPRECATED
mais appellera quand même cette fonction comme un constructeur.
Si __construct() et une méthode du même nom
sont définies, __construct() sera appelé.
Les classes dans les espaces de nom, ou toute classe à partir de PHP 8.0.0,
une méthode du même nom que la classe n'a jamais de signification particulière.
Toujours utiliser __construct() dans du nouveau code.
New in initializers
À partir de PHP 8.1.0, les objets peuvent être utilisé comme valeur par défaut pour les paramètres,
variables statiques, constantes globales et les arguments d'attributs.
Les objets peuvent être désormais passé à define().
Note:
L'utilisation d'un nom de classe dynamique ou non-string ou une class anonyme n'est pas permis.
L'utilisation de déballage d'argument n'est pas permis.
L'utilisation d'expressions pas supportées en tant qu'argument n'est pas permis.
Exemple #4 Utilisation de new dans des initialiseurs
<?php
// All allowed:
static $x = new Foo;
const C = new Foo;
function test($param = new Foo) {}
#[AnAttribute(new Foo)]
class Test {
public function __construct(
public $prop = new Foo,
) {}
}
// All not allowed (compile-time error):
function test(
$a = new (CLASS_NAME_CONSTANT)(), // dynamic class name
$b = new class {}, // anonymous class
$c = new A(...[]), // argument unpacking
$d = new B($abc), // unsupported constant expression
) {}
?>
Méthode de création statique
PHP supporte uniquement un constructeur unique par classe. Cependant, dans
certains cas il peut être désirable de permettre à un objet d'être construit
de manière différente avec des entrées différentes.
La façon recommandée de faire ceci est en utilisant des méthodes statiques
comme une enveloppe du constructeur.
Exemple #5 Utilisant la création via une méthode statique
<?php
class Product {
private ?int $id;
private ?string $name;
private function __construct(?int $id = null, ?string $name = null) {
$this->id = $id;
$this->name = $name;
}
public static function fromBasicData(int $id, string $name): static {
$new = new static($id, $name);
return $new;
}
public static function fromJson(string $json): static {
$data = json_decode($json);
return new static($data['id'], $data['name']);
}
public static function fromXml(string $xml): static {
// Logique personnalisé.
$data = convert_xml_to_array($xml);
$new = new static();
$new->id = $data['id'];
$new->name = $data['name'];
return $new;
}
}
$p1 = Product::fromBasicData(5, 'Widget');
$p2 = Product::fromJson($some_json_string);
$p3 = Product::fromXml($some_xml_string);
Le constructeur peut être rendu privé ou protégé pour empêcher son appel
depuis l'extérieur. Dans ce cas, seul une méthode statique sera capable
d'instancier la classe. Car elles sont dans la même définition de classe
elles ont accès aux méthodes privées, même dans une instance différente de
l'objet. Un constructeur privé est optionnel et peut ou pas faire de sens
en fonction du cas d'utilisation.
Les trois méthodes statiques publiques démontrent alors des manières différentes
d'instancier l'objet.
fromBasicData()
prend les paramètres exacts qui sont nécessaires,
puis créé l'objet en appellant le constructeur puis retournant le résultat.
fromJson()
accepte une chaîne de caractère JSON et fait
du pré-traitement sur lui même pour ce convertir dans le format désiré par
le constructeur. Elle retourne alors le nouvel objet.
-
fromXml()
accepte une chaîne de caractère XML, fait du pré-traitement,
puis créé un objet brut. Le constructeur est appelé, mais comme tout les
paramètres sont optionnels la méthode les ignore. Elle assigne alors les
valeurs aux propriétés de l'objet directement avant de retourner le résultat.
Dans les trois cas, le mot clé static
est traduit en le nom de
la classe dont le code y est. Dans ce cas, Product
.
Destructeur
PHP possède un concept de destructeur similaire à celui d'autres langages
orientés objet, comme le C++
. La méthode destructeur est appelée
dès qu'il n'y a plus de référence sur un objet donné, ou dans n'importe quel
ordre pendant la séquence d'arrêt.
Exemple #6 Exemple avec un Destructeur
<?php
class MyDestructableClass
{
function __construct() {
print "In constructor\n";
}
function __destruct() {
print "Destroying " . __CLASS__ . "\n";
}
}
$obj = new MyDestructableClass();
Tout comme le constructeur, le destructeur parent ne sera pas appelé
implicitement par le moteur. Pour exécuter le destructeur parent, vous
devez appeler explicitement la fonction
parent::__destruct
dans le corps du destructeur.
Tout comme les constructeurs, une classe enfant peut hériter du
destructeur du parent s'il n'en implémente pas un lui même.
Le destructeur sera appelé même si l'exécution du script est stoppée
en utilisant la fonction exit().
Appeler la fonction exit()
dans un destructeur empêchera l'exécution des routines d'arrêt restantes.
Note:
Les destructeurs appelés durant l'arrêt du script sont dans une situation
où les en-têtes HTTP ont déjà été envoyés.
Le dossier de travail dans la phase d'arrêt du script
peut être différent avec certaines APIs (e.g. Apache).
Note:
Tenter de lancer une exception depuis un destructeur (appelé à la fin du script)
entraine une erreur fatale.