diff --git a/language/oop5/decon.xml b/language/oop5/decon.xml index 37467813da..a8222a9f16 100644 --- a/language/oop5/decon.xml +++ b/language/oop5/decon.xml @@ -10,7 +10,7 @@ mixedvalues"" - PHP 5 allows developers to declare constructor methods for classes. + PHP allows developers to declare constructor methods for classes. Classes which have a constructor method call this method on each newly-created object, so it is suitable for any initialization that the object may need before it is used. @@ -26,7 +26,7 @@ - using new unified constructors + Constructors in inheritance - - For backwards compatibility with PHP 3 and 4, if PHP cannot find a - __construct() function for a given - class, it will - search for the old-style constructor function, by the name of the class. - Effectively, it means that the only case that would have compatibility - issues is if the class had a method named - __construct() which was used for - different semantics. - - - - - Old style constructors are DEPRECATED in PHP 7.0, and - will be removed in a future version. You should always use - __construct() in new code. - - Unlike with other methods, PHP will not generate an E_STRICT level error message when @@ -86,28 +67,175 @@ $obj = new OtherSubClass(); than the parent __construct() method has. - As of PHP 5.3.3, methods with the same name as the last element of a - namespaced class name will no longer be treated as constructor. This - change doesn't affect non-namespaced classes. + Constructors are ordinary methods which are called during the instantiation of their + corresponding object. As such, they may define an arbitrary number of arguments, which + may be required, may have a type, and may have a default value. Constructor arguments + are called by placing the arguments in parentheses after the class name. - Constructors in namespaced classes + Using constructor arguments x = $x; + $this->y = $y; } } + +// Pass both parameters. +$p1 = new Point(4, 5); +// Pass only the required parameter. $y will take its default value of 0. +$p2 = new Point(4); +// With named parameters (as of PHP 8.0): +$p3 = new Point(y: 5, x: 4); ?> ]]> - + + If a class has no constructor, or the constructor has no required arguments, the parentheses + may be omitted. + + + Old-style constructors + + Prior to PHP 8.0.0, classes in the global namespace will interpret a method named + the same as the class as an old-style constructor. That syntax is deprecated, + and will result in an E_DEPRECATED error but still call that function as a constructor. + If both __construct() and a same-name method are + defined, __construct() will be called. + + + In namespaced classes, or any class as of PHP 8.0.0, a method named + the same as the class never has any special meaning. + + Always use __construct() in new code. + + + + Constructor Promotion + + As of PHP 8.0.0, constructor parameters may also be promoted to correspond to an + object property. It is very common for constructor parameters to be assigned to + a property in the constructor but otherwise not operated upon. Constructor promotion + provides a short-hand for that use case. The example above could be rewritten as the following. + + + Using constructor property promotion + + + + + + When a constructor argument includes a visibility modifier, PHP will interpret it as + both an object property and a constructor argument, and assign the argument value to + the property. The constructor body may then be empty or may contain other statements. + Any additional statements will be executed after the argument values have been assigned + to the corresponding properties. + + + Not all arguments need to be promoted. It is possible to mix and match promoted and not-promoted + arguments, in any order. Promoted arguments have no impact on code calling the constructor. + + + + Object properties may not be typed callable due to engine ambiguity that would + introduce. Promoted arguments, therefore, may not be typed callable either. Any + other type declaration is permitted, however. + + + + + + Attributes placed on a promoted constructor argument will be replicated to both the property + and argument. + + + + + Static creation methods + + PHP only supports a single constructor per class. In some cases, however, it may be + desirable to allow an object to be constructed in different ways with different inputs. + The recommended way to do so is by using static methods as constructor wrappers. + + + Using static creation methods + +id = $id; + $this->name = $name; + } + + public static function fromBasicData(int $id, string $name): static { + $new = new static($id, $name); + return $new; + } + + public static function fromJson(string $json): static { + $data = json_decode($json); + return new static($data['id'], $data['name']); + } + + public static function fromXml(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); +]]> + + + + The constructor may be made private or protected to prevent it from being called externally. + If so, only a static method will be able to instantiate the class. Because they are in the + same class definition they have access to private methods, even if not of the same object + instance. The private constructor is optional and may or may not make sense depending on + the use case.. + + + The three public static methods then demonstrate different ways of instantiating the object. + + + fromBasicData() takes the exact parameters that are needed, then creates the + object by calling the constructor and returning the result. + fromJson() accepts a JSON string and does some pre-processing on it itself + to convert it into the format desired by the constructor. It then returns the new object. + fromXml() accepts an XML string, preprocesses it, and then creates a bare + object. The constructor is still called, but as all of the parameters are optional the method + skips them. It then assigns values to the object properties directly before returning the result. + + + In all three cases, the static keyword is translated into the name of the class the code is in. + In this case, Product. + + + Destructor