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.