A cosa serve la function __Construct?

Ho notato di __construct molto con le lezioni. Ho fatto un po 'di lettura e navigando sul web, ma non ho trovato una spiegazione che potessi capire. Sto solo iniziando con OOP.

Mi stavo chiedendo se qualcuno potesse darmi un'idea generale di cosa sia, e quindi un semplice esempio di come viene utilizzato con PHP?

__construct stato introdotto in PHP5 ed è il modo giusto per definire i tuoi, bene, costruttori (in PHP4 hai usato il nome della class per un constructor). Non sei obbligato a definire un constructor nella tua class, ma se desideri passare qualsiasi parametro sulla costruzione di un object, ne hai bisogno.

Un esempio potrebbe andare così:

 class Database { protected $userName; protected $password; protected $dbName; public function __construct ( $UserName, $Password, $DbName ) { $this->userName = $UserName; $this->password = $Password; $this->dbName = $DbName; } } // and you would use this as: $db = new Database ( 'user_name', 'password', 'database_name' ); 

Tutto il resto è spiegato nel manuale PHP: clicca qui

__construct() è il nome del metodo per il constructor . Il constructor viene chiamato su un object dopo che è stato creato ed è un buon posto where inserire il codice di initialization, ecc.

 class Person { public function __construct() { // Code called for each new Person we create } } $person = new Person(); 

Un constructor può accettare i parametri nel modo normale, che vengono passati quando viene creato l'object, ad es

 class Person { public $name = ''; public function __construct( $name ) { $this->name = $name; } } $person = new Person( "Joe" ); echo $person->name; 

A differenza di altri linguaggi (ad esempio Java), PHP non support il sovraccarico del constructor (ovvero, avere più costruttori che accettano parametri diversi). È ansible get questo effetto utilizzando methods statici.

Nota : ho recuperato questo dal registro della risposta accettata (al momento della stesura di questo documento).

È un altro modo per dichiarare il constructor. Puoi anche usare il nome della class, ad esempio:

 class Cat { function Cat() { echo 'meow'; } } 

e

 class Cat { function __construct() { echo 'meow'; } } 

Sono equivalenti Vengono chiamati each volta che viene creata una nuova istanza della class, in questo caso verranno chiamati con questa row:

 $cat = new Cat(); 

Penso che questo sia importnte per la comprensione dello scopo del constructor.
Anche dopo aver letto le risposte qui mi ci sono voluti alcuni minuti per realizzare e qui è il motivo.
Ho preso l'abitudine di codificare esplicitamente tutto ciò che è iniziato o si verifica. In altre parole questa sarebbe la mia class di gatto e come la chiamerei.

class_cat.php

 class cat { function speak() { echo "meow"; } } 

somepage.php

 include('class_cat.php'); mycat = new cat; $speak = cat->speak(); echo $speak; 

Dove negli esempi di "class cat" di @Logan Serman si presume che each volta che crei un nuovo object di class "cat", vuoi che il gatto "miagoli" piuttosto che aspettare che tu chiami la function per farlo miagolare.

In questo modo la mia mente stava pensando esplicitamente a where il metodo del constructor usava implicitamente e questo all'inizio lo rendeva difficile da capire.

Il constructor è un metodo che viene chiamato automaticamente sull'istanza della class. Il che significa che i contenuti di un constructor vengono elaborati senza chiamate di metodo separate. I contenuti di una parentesi di parole chiave della class vengono passati al metodo del constructor.

Spero che questo aiuti:

 <?php // The code below creates the class class Person { // Creating some properties (variables tied to an object) public $isAlive = true; public $firstname; public $lastname; public $age; // Assigning the values public function __construct($firstname, $lastname, $age) { $this->firstname = $firstname; $this->lastname = $lastname; $this->age = $age; } // Creating a method (function tied to an object) public function greet() { return "Hello, my name is " . $this->firstname . " " . $this->lastname . ". Nice to meet you! :-)"; } } // Creating a new person called "boring 12345", who is 12345 years old ;-) $me = new Person('boring', '12345', 12345); // Printing out, what the greet method returns echo $me->greet(); ?> 

Per ulteriori informazioni è necessario andare su codecademy.com

 class Person{ private $fname; private $lname; public function __construct($fname,$lname){ $this->fname = $fname; $this->lname = $lname; } } $objPerson1 = new Person('john','smith'); 

Il metodo __construct serve per passare i parametri quando crei per la prima volta un object, che è una cosa comune da fare. Se non si desidera passare alcun parametro al momento della creazione, non è necessario.

Così:

 // Create a new class, and include a __construct method class Task { public $title; public $description; public function __construct($title, $description){ $this->title = $title; $this->description = $description; } } // Create a new object, passing in a $title and $description $task = new Task('Learn OOP','This is a description'); // Try it and see var_dump($task->title, $task->description); 

Credo che la function __construct () {...} sia un pezzo di codice che può essere riutilizzato più e più volte in sostituzione di TheActualFunctionName () {...} . Se cambi il nome della CLASSE, non devi cambiare all'interno del codice perché la generica __construct si riferisce sempre al nome effettivo della class … qualunque esso sia. Codice less … o?

__Construct è un metodo per inizializzare il nuovo object prima che venga utilizzato.
http://php.net/manual/en/language.oop5.decon.php#object.construct

Nota: i costruttori principali non vengono chiamati implicitamente se la class figlio definisce un constructor. Per eseguire un constructor genitore, è richiesta una chiamata a parent::__construct() all'interno del constructor figlio. Se il figlio non definisce un constructor, può essere ereditato dalla class padre proprio come un normale metodo di class (se non è stato dichiarato come privato).

__Costruct viene sempre chiamato durante la creazione di nuovi oggetti o vengono richiamati al momento dell'initialization. È adatto a qualsiasi initialization di cui l'object potrebbe aver bisogno prima di essere utilizzato. Il metodo __construct è il primo metodo eseguito in class.

  class Test { function __construct($value1,$value2) { echo "Inside Construct"; echo $this->value1; echo $this->value2; } } // $testObject = new Test('abc','123');