php constructor,PHP: Constructori și Destructori - Manual

Constructor

__construct

( ...$values= ""

) : void

PHP 5 permite programatorilor să definească constructori pentru clase.

Clasele care au definit un constructor vor apela această metodă la fiecare

obiect nou creat, pentru ca acesta (obiectul) să fie utilizabil pentru

inițializare înante de a fi folosit.

Notă:

Constructorul-părinte nu este apelat implicit dacă clasa-fiică definește

un constructor. Pentru a apela un constructor-părinte, este necesar de a

apela parent::__construct() din cadrul

constructorului-fiu. Dacă clasa-fiică nu definește un constructor, atunci

acesta poate fi moștenit de la clasa-părinte la fel ca o metodă normală a

clasei (dacă aceasta nu a fost declarată ca privată).

Example #1 utilizarea noilor constructori unificați

function__construct() {

print"In BaseClass constructor\n";

}

}

classSubClassextendsBaseClass{

function__construct() {parent::__construct();

print"In SubClass constructor\n";

}

}

classOtherSubClassextendsBaseClass{// inherits BaseClass's constructor}// In BaseClass constructor$obj= newBaseClass();// In BaseClass constructor

// In SubClass constructor$obj= newSubClass();// In BaseClass constructor$obj= newOtherSubClass();?>

Spre deosebire de alte metode, PHP nu va genera un mesaj de eroare de nivel

E_STRICT atunci când __construct()

este suprascrisă cu alți parametri decât cei ai metodei

__construct() din clasa-părinte.

Constructorii sunt metode apelate la inițializarea obiectelor.

Aceștia pot fi definiți cu un număr arbitrar de argumente, care

pot fi opționali sau nu, pot ave tip, și pot avea valoare implicită. Argumentele pentru

constructori se pun între paranteze după numele clasei.

Example #2 Constructori în clasele cu spații de nume

protectedint $x;

protectedint $y;

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

}

}// Apel cu ambii parametrii$p1= newPoint(4,5);// Apel cu argumentul necesar. $y va prelua valoare implictă 0.$p2= newPoint(4);// Cu argumente numite (începând cu PHP 8.0):$p3= newPoint(y:5,x:4);?>

Dacă o clasă nu are constructor, sau constructorul nu are nici un argument necesar, parantezele

pot fi omise.

Constructorii de stil vechi

Înainte de PHP 8.0.0, clasele din namespaceul global interpretau o metodă cu același nume

ca și clasa ca un constructor de stil vechi. Acea syntaxă este învechită și nerecomandată,

iar utilizarea ei va genera or eroare de tip E_DEPRECATED dar metoda constructor va fi apelată.

Dacă atât __construct() cât și o motodă cu acelasi nume cu al clasei sunt

definite, numai __construct() va fi apelat.

În clasele din namespace-uri, sau orice altă clasă începând cu PHP 8.0.0, o metodă cu același nume

cu al clasei nu are însemnătate specială.

Folosiți întotdeauna __construct() în cod nou.

Promovarea prin constructor

Începând cu PHP 8.0.0, parametrii constructorului pot fi promovati să corespundă cu o

proprietate a objectului. Este foarte des întâlnit ca parametrii constructorului să fie asignat

unei proprietăți în constructor și apoi să nu se mai lucreze cu acea proprietate. Promovarea prin constructor

oferă o scurtătură a acestul caz. Exemplul de mai sus poate fi rescris în forma următoare.

Example #3 Folosirea promovării prin constructor

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

}

}

Atunci când argumentele constructorului include modificatori de vizibilitate, PHP îl va interpreta atât ca

o proprietate a obiectului cât și drept argument al constructorului, va asigna valoarea argumentului la

proprietatea respectivă. Corpul constructorului poate fi gol sau poate contine alte declarații.

Declarațiile vor fi executate după ce valorile au fost asignate

la proprietățile corespunzătoare.

Nu este necesar să fie promovate toate argumentele. Este posibil să se amestece argumente/proprietăți promovate și nepromovate,

în orice ordine. Argumentele promovate nu au nici un impact asupra codului care apelează constructorul.

Notă:

Proprietățile obiectelor nu pot fi de tipul declarații de tip sunt permise.

Notă:

Atributele plasate ca argumente la un constructor promovat vor fi replicate și ca proprietăți dar

și ca argumente.

Metode de creare statice

PHP suportă un singur constructor într-o clasă. În unele cazuri, însă, este nevoie

să permitem crearea unui obiect în diferite feluri cu intrări diferite.

Metoda recomandată este folosind metode statice care împacheterază constructorul.

Example #4 Folosirea metodelor de creare statice

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 {// Put your own logic here.$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);

Constructorul poate fi făcut private sau protected pentru a preveni apelarea din exterior.

Dacă se alege această cale, numai o metodă statică va putea instanția classa. Pentru că sunt definite în

aceeași clasă au access la metodele private, chiar dacă obiectele instanțiate sunt

diferite. Un constructor private este opțional și poate fi o alegere bună în funcție

de cerințe...

Cele trei metode statice publice demonstrează feluri diferite de instanțiere a obiectelor.

fromBasicData() permite exact parametrii necesari, și apoi crează

obiectul apelând constructorul și returnând rezultatul.

fromJson() acceptă un text în format JSON și îl pre-procesează pentru într-un

format necesar constructorului. Apoi returnează obiectul nou.

fromXml() acceptă un text XML, în pro-procesează, apoi crează un obiect

gol. Constructorul este apelat, dar pentru că toți parapetrii sunt opționali nu sunt

pasați. Apoi asignează valori corecte proprietăților obiectului înainte de a întoarce rezultatul.

În toate cele trei cazuri, cuvântul cheie staticeste tradus în numele clasei în care este scris acest cod.

În acest caz, Product.