Le constructeur est une méthode spéciale d'une classe, permettant d'initialiser les membres de cette classe et également, d'exécuter différentes opérations initiales définies par le programmeur.
L'instanciation d'une classe (ou la création d'un objet) nécessite l'utilisation de l'opérateur new appelant un constructeur.
$ref_objet = new Constructeur([$arg1, ..., $argN]);
Le nom du constructeur porte exactement le même nom que la classe courante.
class NomClasse {
public function NomClasse([$arg1, ..., $argN]){
//...
}
}Le langage PHP utilise également une fonction spécifique, à déclarer au sein de la classe destinée à l'instanciation. Il s'agît de la méthode __construct().
ref_objet = new IdentificateurClasse();
En l'absence d'une déclaration de constructeur dans une classe, le compilateur Java en génère automatiquement un par défaut, lequel n'aura pas d'argument et aucune autre fonction que de créer un objet.
class UneClasse {
// Aucun constructeur défini
...
}
// est équivalent à
class UneClasse {
// Constructeur de la classe UneClasse
public function __construct(){
//Initialisation des membres de la classe
}
...
}Afin d'éviter cette création automatique, il peut être parfois préférable de déclarer un constructeur mieux adapté aux besoins de la classe.
class NomClasse {
// méthode constructeur
modificateur __construct([Paramètre, ...]) {
// Bloc d'instructions...
}
}
...
//Instanciation de la classe
$ref_objet = new NomClasse([Arguments]);Le constructeur doit avoir un identificateur en tout point semblable à celui de sa classe.
Les constructeurs peuvent être déclarés avec un modificateur d'accès public, protected, par défaut ou private.
Les constructeurs sont par défaut uniquement accessibles dans le paquetage de la classe parente.
Le modificateur private entraîne l'impossibilité d'instancier la classe du constructeur et également de l'étendre.
Un constructeur ne peut être déclaré avec les modificateurs suivants : abstract, static, final.
Le constructeur ne peut retourner une valeur, et donc, sa déclaration ne contient aucun type de retour. En fait, l'instance de l'objet est toujours le type retourné par un constructeur.
Le constructeur peut posséder un à plusieurs paramètres permettant notamment l'affectation des champs de l'objet avec des valeurs fournies par l'utilisateur.
class Article {
private $idProduit;
private $prix;
private $reduction;
public function __construct($idProduit, $prix, $reduction) {
$this->idProduit = $idProduit;
$this->prix = $prix;
$this->reduction = $reduction;
}
}
$livre = new Article(9782212075021, 55.0, 5.0);La clause throws optionnelle permet d'indiquer que le constructeur peut déclencher les exceptions spécifiées.
La définition d'un constructeur doit apparaître au moins une fois dans une classe, mais n'est en aucun cas une nécessité absolue, dans la mesure où aucune initialisation particulière ne serait nécessaire au démarrage de l'objet.
Parfois, il est utile de définir dans une classe, plusieurs constructeurs avec des signatures distinctes (voir La surcharge des méthodes). Cela permet d'initialiser un objet de plusieurs façons différentes.
class Article {
private $nomProduit;
private $idProduit;
private $prix;
private $reduction;
public Article($idProduit, $prix, $reduction) {
$this->idProduit = $idProduit;
$this->prix = $prix;
$this->reduction = $reduction;
}
public Article($idProduit, , $nomProduit, $prix, $reduction) {
$this->idProduit = $idProduit;
$this->nomProduit = $nomProduit;
$this->prix = $prix;
$this->reduction = $reduction;
}
}
$livre1 = new Article(9782744090004, 49.0, 0.0);
$livre2 = new Article(9782744090004, "Maîtrisez Java 2", 49.0, 0.0);Il est possible également d'utiliser les fonctions func_num_args(), func_get_arg(0) et func_get_args() pour récupérer les arguments passés au constructeur et réagir en fonction des arguments passés.
function __construct() {
$nb_args = func_num_args();
if($nb_args == 3){
$this->idProduit = func_get_arg(0);
$this->prix = func_get_arg(1);
$this->reduction = func_get_arg(2);
}
else if($nb_args == 4){
$this->idProduit = func_get_arg(0);
$this->nomProduit = func_get_arg(1);
$this->prix = func_get_arg(2);
$this->reduction = func_get_arg(3);
}
else {
echo 'Le nombre d'arguments est incorrect !';
}
}Afin de s'assurer du type des arguments, il peut être souhaitable d'utiliser les fonctions de tests de type, telles que is_array(), is_bool(), is_int(), is_float(), is_string(), etc..
if(is_long(func_get_arg($indice))
$this->idProduit = func_get_arg($indice);
else if(is_float(func_get_arg($indice))
$this->prix = func_get_arg($indice);
else if(is_string(func_get_arg($indice))
$this->nomProduit = func_get_arg($indice);
//...Utilisé avec des constructeurs multiples, l'opérateur de résolution de portée :: permet d'appeler le constructeur possèdant les arguments correspondants au sein de la classe courante (self::) ou de la classe parente (parent::). Ceci permet d'abréger la rédaction des affectations dans les définitions de constructeurs.
class Produit {
private $nomProduit;
private $idProduit;
private $prix;
private $reduction;
function __construct($nomProduit,
$idProduit,
$prix,
$reduction) {
$this->idProduit = $idProduit;
$this->nomProduit = $nomProduit;
$this->prix = $prix;
$this->reduction = $reduction;
}
}
class Livre extends Produit {
private $auteur;
private $editeur;
private $nb_pages;
function _construct($auteur,
$editeur,
$nb_pages) {
$this->auteur = $auteur;
$this->editeur = $editeur;
$this->nb_pages = $nb_pages;
}
function __construct($nomProduit,
$idProduit,
$prix,
$reduction,
$auteur,
$editeur,
$nb_pages) {
parent::__construct($nomProduit,
$idProduit,
$prix,
$reduction);
self::__construct($auteur,
$editeur,
$nb_pages);
}
}
$livre = new Article(9782746024588,
'PHP 5',
27.14,
0.0,
'Olivier Heurtel',
'Eni Editions',
504);A l'opposé des constructeurs, PHP 5 introduit un concept de destructeur. La méthode destructeur, dénommée __destruct(), est destinée à décharger les ressources utilisées par l'objet. cette méthode est appelée automatiquement après que la dernière référence à un objet est supprimée ou lorsque cet objet est explicitement détruit.
class UneClasse {
private $var;
function __construct($var) {
$this->var = $var;
}
function __destruct() {
$this->name = Null;
}
}
//Appel du constructeur
$objet = new UneClasse();
//Appel du destructeur
$objet = Null;