php headet,PHP: Constructeurs et destructeurs - Manual

Constructeur

__construct

( ...$values= ""

) : void

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 parent, 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

function__construct() {

print"Dans le constructeur de BaseClass\n";

}

}

classSubClassextendsBaseClass{

function__construct() {parent::__construct();

print"Dans le constructeur de SubClass\n";

}

}

classOtherSubClassextendsBaseClass{// Constructeur hérité de BaseClass}// Dans le constructeur de BaseClass$obj= newBaseClass();// Dans le constructeur de BaseClass

// Dans le constructeur de SubClass$obj= newSubClass();// Dans le constructeur de BaseClass$obj= newOtherSubClass();?>

À la différence des autres méthodes, __construct()

est exclus des règles de compatibilités des signatures

usuel 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

protectedint $x;

protectedint $y;

public function__construct(int $x,int $y=0) {$this->x=$x;$this->y=$y;

}

}// Pass both parameters.$p1= newPoint(4,5);// Pass only the required parameter. $y will take its default value of 0.$p2= newPoint(4);// With named parameters (as of PHP 8.0):$p3= newPoint(y:5,x:4);?>

Si une classe n'a pas de constructeur, ou le constructeur n'a pas d'arguments requis,

les parenthèses peuvent être omit.

Style ancien des constructeurs

Antérieur à PHP 8.0.0, les classes dans le nom d'espace global interpréteront une

méthode qui à la 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éfinie, __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.

Promotion du Constructeur

À partir de PHP 8.0.0, les paramètres du constructeur peuvent être promu pour

correspondre à une propriété de l'objet. Il est très commun pour les paramètres

d'un constructeur d'être assigné à une propriété sans effectuer d'opérations dessus.

La promotion du constructeur fournie un raccourci pour ce cas d'utilisation.

L'exemple ci-dessus peut être réécrit de la façon suivante.

Exemple #3 Utilisant la promotion de propriété de constructeur

public function__construct(protectedint $x, protectedint $y=0) {

}

}

Quand un argument de constructeur inclus un modificateur de visibilité, PHP l'interprétera

comme une propriété d'objet et un argument du constructeur, et assigne la valeur de l'argument

à la propriété. Le corps du constructeur peut être alors vide ou peut contenir d'autres

déclarations. Toutes déclarations additionnelles seront exécuté apr_s que la valeur de

l'argument a été assigné à leur propriétés correspondantes.

Tous les arguments ne doivent pas être promu. Il est possible de mélanger et assortir les

arguments promu et non-promu, dans n'importe quel ordre. Les arguments promu n'ont aucun impact

sur du code appellant le constructeur.

Note:

Les propriétés d'objet ne peuvent être typé déclaration de type est permis.

Note:

Les attributs placé sur un

argument de constructeur promu seront reproduit à la fois sur la

propriété ainsi que sur l'argument.

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é de faire ceci est en utilisant des méthodes statiques

comme une enveloppe du constructeur.

Exemple #4 Utilisant la création via une méthode statique

private ?int $id;

private ?string $name;

private function__construct(?int $id=null, ?string $name=null) {$this->id=$id;$this->name=$name;

}

public static functionfromBasicData(int $id,string $name): static {$new= new static($id,$name);

return$new;

}

public static functionfromJson(string $json): static {$data=json_decode($json);

return new static($data['id'],$data['name']);

}

public static functionfromXml(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 publique démontrent alors des manières différentes

d'instancier l'objet.

fromBasicData() prend les paramètres exacte qui sont nécessaire,

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 ignores. 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.