Constructor (object-oriented programming)
Special function called to create an object
- 43 min read
- 4 chapters
Learn it on Lably
A constructor resembles an instance method, but it differs from a method in that it has no explicit return type, it is not implicitly inherited and it usually has different rules for scope modifiers. Constructors often have the same name as the declaring class. They have the task of initializing the object's data members and of establishing the invariant of the class, failing if the invariant is invalid. A properly written constructor leaves the resulting object in a valid state. Immutable objects must be initialized in a constructor.
Most languages allow overloading the constructor in that there can be more than one constructor for a class, with differing parameters. Some languages take consideration of some special types of constructors. Constructors, which concretely use a single class to create objects and return a new instance of the class, are abstracted by factories, which also create objects but can do so in various ways, using multiple classes or different allocation schemes such as an object pool.
Types
Parameterized constructors
Constructors that can take at least one argument are termed as parameterized constructors. When an object is declared in a parameterized constructor, the initial values have to be passed as arguments to the constructor function. The normal way of object declaration may not work. The constructors can be called explicitly or implicitly. The method of calling the constructor implicitly is also called the shorthand method.
<span id="mwIw"></span><span class="k" id="mwJA">class</span><span class="w" id="mwJQ"> </span><span class="nc" id="mwJg">Point</span><span class="w" id="mwJw"> </span><span class="p" id="mwKA">{</span> <span class="k" id="mwKQ">private</span><span class="o" id="mwKg">:</span> <span class="w" id="mwKw"> </span><span class="kt" id="mwLA">int</span><span class="w" id="mwLQ"> </span><span class="n" id="mwLg">x</span><span class="p" id="mwLw">;</span> <span class="w" id="mwMA"> </span><span class="kt" id="mwMQ">int</span><span class="w" id="mwMg"> </span><span class="n" id="mwMw">y</span><span class="p" id="mwNA">;</span> <span class="k" id="mwNQ">public</span><span class="o" id="mwNg">:</span> <span class="w" id="mwNw"> </span><span class="n" id="mwOA">Point</span><span class="p" id="mwOQ">()</span><span class="w" id="mwOg"> </span><span class="o" id="mwOw">=</span><span class="w" id="mwPA"> </span><span class="k" id="mwPQ">default</span><span class="p" id="mwPg">;</span> <span class="w" id="mwPw"> </span><span class="n" id="mwQA">Point</span><span class="p" id="mwQQ">(</span><span class="kt" id="mwQg">int</span><span class="w" id="mwQw"> </span><span class="n" id="mwRA">x</span><span class="p" id="mwRQ">,</span><span class="w" id="mwRg"> </span><span class="kt" id="mwRw">int</span><span class="w" id="mwSA"> </span><span class="n" id="mwSQ">y</span><span class="p" id="mwSg">)</span><span class="o" id="mwSw">:</span> <span class="w" id="mwTA"> </span><span class="n" id="mwTQ">x</span><span class="p" id="mwTg">{</span><span class="n" id="mwTw">x</span><span class="p" id="mwUA">},</span><span class="w" id="mwUQ"> </span><span class="n" id="mwUg">y</span><span class="p" id="mwUw">{</span><span class="n" id="mwVA">y</span><span class="p" id="mwVQ">}</span><span class="w" id="mwVg"> </span><span class="p" id="mwVw">{}</span><span class="w" id="mwWA"> </span><span class="c1" id="mwWQ">// Parameterized constructor</span> <span class="p" id="mwWg">};</span><span id="mwXQ"></span><span class="n" id="mwXg">Point</span><span class="w" id="mwXw"> </span><span class="n" id="mwYA">p</span><span class="w" id="mwYQ"> </span><span class="o" id="mwYg">=</span><span class="w" id="mwYw"> </span><span class="n" id="mwZA">Point</span><span class="p" id="mwZQ">(</span><span class="mi" id="mwZg">0</span><span class="p" id="mwZw">,</span><span class="w" id="mwaA"> </span><span class="mi" id="mwaQ">50</span><span class="p" id="mwag">);</span><span class="w" id="mwaw"> </span><span class="c1" id="mwbA">// Explicit call.</span> <span class="n" id="mwbQ">Point</span><span class="w" id="mwbg"> </span><span class="nf" id="mwbw">p2</span><span class="p" id="mwcA">(</span><span class="mi" id="mwcQ">0</span><span class="p" id="mwcg">,</span><span class="w" id="mwcw"> </span><span class="mi" id="mwdA">50</span><span class="p" id="mwdQ">);</span><span class="w" id="mwdg"> </span><span class="c1" id="mwdw">// Implicit call.</span>
Default constructors
If the programmer does not supply a constructor for an instantiable class, Java compiler inserts a default constructor into the code. This constructor is known as default constructor. It would not be found in source code (the .java file) as it would be inserted into the code during compilation and exists in .class file. The behavior of the default constructor is language dependent. It may initialize data members to zero or other same values, or it may do nothing at all. In Java, a "default constructor" refer to a nullary constructor that is automatically generated by the compiler if no constructors have been defined for the class or in the absence of any programmer-defined constructors (e.g. in Java, the default constructor implicitly calls the superclass's nullary constructor, then executes an empty body). All fields are left at their initial value of 0 (integer types), 0.0 (floating-point types), false (boolean type), or null (reference types), etc.
<span id="mwiQ"></span><span class="k" id="mwig">class</span><span class="w" id="mwiw"> </span><span class="nc" id="mwjA">Point</span><span class="w" id="mwjQ"> </span><span class="p" id="mwjg">{</span> <span class="k" id="mwjw">private</span><span class="o" id="mwkA">:</span> <span class="w" id="mwkQ"> </span><span class="kt" id="mwkg">int</span><span class="w" id="mwkw"> </span><span class="n" id="mwlA">x</span><span class="p" id="mwlQ">;</span> <span class="w" id="mwlg"> </span><span class="kt" id="mwlw">int</span><span class="w" id="mwmA"> </span><span class="n" id="mwmQ">y</span><span class="p" id="mwmg">;</span> <span class="k" id="mwmw">public</span><span class="o" id="mwnA">:</span> <span class="w" id="mwnQ"> </span><span class="n" id="mwng">Point</span><span class="p" id="mwnw">(</span><span class="kt" id="mwoA">int</span><span class="w" id="mwoQ"> </span><span class="n" id="mwog">x</span><span class="w" id="mwow"> </span><span class="o" id="mwpA">=</span><span class="w" id="mwpQ"> </span><span class="mi" id="mwpg">0</span><span class="p" id="mwpw">,</span><span class="w" id="mwqA"> </span><span class="kt" id="mwqQ">int</span><span class="w" id="mwqg"> </span><span class="n" id="mwqw">y</span><span class="w" id="mwrA"> </span><span class="o" id="mwrQ">=</span><span class="w" id="mwrg"> </span><span class="mi" id="mwrw">0</span><span class="p" id="mwsA">);</span><span class="w" id="mwsQ"> </span><span class="c1" id="mwsg">// Default constructor.</span> <span class="p" id="mwsw">};</span>Copy constructors
Like C++, Java also supports "Copy Constructors". But, unlike C++, Java does not create a default copy constructor even if no such copy constructor is specified. Copy constructors define the actions performed by the compiler when copying class objects. A Copy constructor has one formal parameter that is the type of the class (the parameter may be a reference to an object). It is used to create a copy of an existing object of the same class. Even though both classes are the same, it counts as a conversion constructor. While copy constructors are usually abbreviated copy ctor or cctor, they have nothing to do with class constructors used in .NET using the same abbreviation.
Conversion constructors
Conversion constructors provide a means for a compiler to implicitly create an object belonging to one class based on an object of a different type. These constructors are usually invoked implicitly to convert arguments or operands to an appropriate type, but they may also be called explicitly.
Move constructors
In C++, move constructors take an Rvalue reference to an object of the class, and are used to implement ownership transfer of the parameter object's resources.
Sign in to keep reading
3 more chapters are free with a Lably account.
Syntax
- Java, C++, C#, ActionScript, PHP 4, and MATLAB have a naming convention in which constructors have the same name as the class with which they are associated.
- In C and Rust (programming language), there are no language-level constructors. In C, objects are created by a struct initializer, or a function that creates such an instance of an object. Similarly in Rust, objects are created as struct literals, but may also include a constructor-like associated function (typically named
new,from, etc.) - In Crystal, similarly to Python, the constructor is split between two methods:
newandinitialize. The compiler defines thenewmethod, requiring only that the user defineinitialize. Although the Crystal compiler automatically defines it, the user may manually definenew, and even forego use of defaultnewand define their own constructors. - In PHP 5, a recommended name for a constructor is
__construct. For backwards compatibility, a method with the same name as the class will be called if__constructmethod can not be found. Since PHP 5.3.3, this works only for non-namespaced classes. - In PHP 7, you should always name the constructor as
__construct. Methods with the same name as the class will trigger an E_DEPRECATED level error. - In Perl, constructors are, by convention, named "new" and have to do a fair amount of object creation.
- In Moose object system for Perl, constructors (named
new) are automatically created and are extended by specifying aBUILDmethod. - In Visual Basic .NET, the constructor is called "
New". - In Python, the constructor is split over two methods, "
__new__" and "__init__". The__new__method is responsible for allocating memory for the instance, and receives the class as an argument (conventionally called "cls"). The__init__method (often called "the initialiser") is passed the newly created instance as an argument (conventionally called "self"). - Object Pascal constructors are signified by the keyword "
constructor" and can have user-defined names (but are mostly called "Create"). - In Objective-C, the constructor method is split across two methods, "
alloc" and "init" with theallocmethod setting aside (allocating) memory for an instance of the class, and theinitmethod handling the bulk of initializing the instance. A call to the method "new" invokes both theallocand theinitmethods, for the class instance.
Memory organization
In Java, C#, and VB .NET, the constructor creates reference type objects on the heap, whereas primitive types (such as int, double, etc.) are stored on the stack (though some languages allow for manually allocating objects on the stack through a stackalloc modifier). VB .NET and C# also allow the use of the new operator to create value type objects, but these value type objects are created on the stack regardless of whether the operator is used or not. In these languages, object destruction occurs when the object has no references and then gets destroyed by the garbage collector.
In C++, objects are created on the stack when the constructor is invoked without the new operator, and created on the heap when the constructor is invoked with the new operator (which returns a pointer to the object). Stack objects are deleted implicitly when they go out of scope, while heap objects must be deleted implicitly by a destructor or explicitly by using the delete operator. By using the "Resource Acquisition is Initialization" (RAII) idiom, resource management can be greatly simplified.
Language details
Constructors are implemented in different programming languages in various ways, including:
C
In C, there are no constructors. However, functions can be defined to create an object, similar to a constructor.
<span id="mwARs"></span><span class="cp" id="mwARw">#include</span><span class="w" id="mwAR0"> </span><span class="cpf" id="mwAR4"><stdlib.h></span> <span class="k" id="mwAR8">typedef</span><span class="w" id="mwASA"> </span><span class="k" id="mwASE">struct</span><span class="w" id="mwASI"> </span><span class="p" id="mwASM">{</span> <span class="w" id="mwASQ"> </span><span class="kt" id="mwASU">char</span><span class="o" id="mwASY">*</span><span class="w" id="mwASc"> </span><span class="n" id="mwASg">name</span><span class="p" id="mwASk">;</span> <span class="w" id="mwASo"> </span><span class="kt" id="mwASs">int</span><span class="w" id="mwASw"> </span><span class="n" id="mwAS0">age</span><span class="p" id="mwAS4">;</span> <span class="p" id="mwAS8">}</span><span class="w" id="mwATA"> </span><span class="n" id="mwATE">Person</span><span class="p" id="mwATI">;</span> <span class="c1" id="mwATM">// this method creates an instance of Person</span> <span class="n" id="mwATQ">Person</span><span class="o" id="mwATU">*</span><span class="w" id="mwATY"> </span><span class="nf" id="mwATc">createPerson</span><span class="p" id="mwATg">(</span><span class="k" id="mwATk">const</span><span class="w" id="mwATo"> </span><span class="kt" id="mwATs">char</span><span class="w" id="mwATw"> </span><span class="n" id="mwAT0">name</span><span class="p" id="mwAT4">[],</span><span class="w" id="mwAT8"> </span><span class="kt" id="mwAUA">int</span><span class="w" id="mwAUE"> </span><span class="n" id="mwAUI">age</span><span class="p" id="mwAUM">)</span><span class="w" id="mwAUQ"> </span><span class="p" id="mwAUU">{</span> <span class="w" id="mwAUY"> </span><span class="n" id="mwAUc">Person</span><span class="o" id="mwAUg">*</span><span class="w" id="mwAUk"> </span><span class="n" id="mwAUo">p</span><span class="w" id="mwAUs"> </span><span class="o" id="mwAUw">=</span><span class="w" id="mwAU0"> </span><span class="p" id="mwAU4">(</span><span class="n" id="mwAU8">Person</span><span class="o" id="mwAVA">*</span><span class="p" id="mwAVE">)</span><span class="n" id="mwAVI">malloc</span><span class="p" id="mwAVM">(</span><span class="k" id="mwAVQ">sizeof</span><span class="p" id="mwAVU">(</span><span class="n" id="mwAVY">Person</span><span class="p" id="mwAVc">));</span> <span class="w" id="mwAVg"> </span><span class="k" id="mwAVk">if</span><span class="w" id="mwAVo"> </span><span class="p" id="mwAVs">(</span><span class="o" id="mwAVw">!</span><span class="n" id="mwAV0">p</span><span class="p" id="mwAV4">)</span><span class="w" id="mwAV8"> </span><span class="p" id="mwAWA">{</span> <span class="w" id="mwAWE"> </span><span class="k" id="mwAWI">return</span><span class="w" id="mwAWM"> </span><span class="nb" id="mwAWQ">NULL</span><span class="p" id="mwAWU">;</span> <span class="w" id="mwAWY"> </span><span class="p" id="mwAWc">}</span> <span class="w" id="mwAWg"> </span><span class="n" id="mwAWk">strcpy</span><span class="p" id="mwAWo">(</span><span class="n" id="mwAWs">p</span><span class="o" id="mwAWw">-></span><span class="n" id="mwAW0">name</span><span class="p" id="mwAW4">,</span><span class="w" id="mwAW8"> </span><span class="n" id="mwAXA">name</span><span class="p" id="mwAXE">);</span> <span class="w" id="mwAXI"> </span><span class="n" id="mwAXM">p</span><span class="o" id="mwAXQ">-></span><span class="n" id="mwAXU">age</span><span class="w" id="mwAXY"> </span><span class="o" id="mwAXc">=</span><span class="w" id="mwAXg"> </span><span class="n" id="mwAXk">age</span><span class="p" id="mwAXo">;</span> <span class="w" id="mwAXs"> </span><span class="k" id="mwAXw">return</span><span class="w" id="mwAX0"> </span><span class="n" id="mwAX4">p</span><span class="p" id="mwAX8">;</span> <span class="p" id="mwAYA">}</span> <span class="c1" id="mwAYE">// this method destroys an instance of Person</span> <span class="kt" id="mwAYI">void</span><span class="w" id="mwAYM"> </span><span class="nf" id="mwAYQ">destroyPerson</span><span class="p" id="mwAYU">(</span><span class="n" id="mwAYY">Person</span><span class="o" id="mwAYc">*</span><span class="w" id="mwAYg"> </span><span class="n" id="mwAYk">p</span><span class="p" id="mwAYo">)</span><span class="w" id="mwAYs"> </span><span class="p" id="mwAYw">{</span> <span class="w" id="mwAY0"> </span><span class="k" id="mwAY4">if</span><span class="w" id="mwAY8"> </span><span class="p" id="mwAZA">(</span><span class="n" id="mwAZE">p</span><span class="p" id="mwAZI">)</span><span class="w" id="mwAZM"> </span><span class="p" id="mwAZQ">{</span> <span class="w" id="mwAZU"> </span><span class="n" id="mwAZY">free</span><span class="p" id="mwAZc">(</span><span class="n" id="mwAZg">p</span><span class="o" id="mwAZk">-></span><span class="n" id="mwAZo">name</span><span class="p" id="mwAZs">);</span> <span class="w" id="mwAZw"> </span><span class="n" id="mwAZ0">free</span><span class="p" id="mwAZ4">(</span><span class="n" id="mwAZ8">p</span><span class="p" id="mwAaA">);</span> <span class="w" id="mwAaE"> </span><span class="p" id="mwAaI">}</span> <span class="p" id="mwAaM">}</span>C++
In C++, the name of the constructor is the name of the class. It returns nothing. It can have parameters like any member function. Constructor functions are usually declared in the public section, but can also be declared in the protected and private sections, if the user wants to restrict access to them.
The constructor has two parts. First is the initializer list which follows the parameter list and before the method body. It starts with a colon and entries are comma-separated. The initializer list is not required, but offers the opportunity to provide values for data members and avoid separate assignment statements. The initializer list is required if there are const or reference type data members, or members that do not have parameterless constructor logic. Assignments occur according to the order in which data members are declared (even if the order in the initializer list is different). The second part is the body, which is a normal method body enclosed in curly brackets. It is generally cheaper and better practice to use the initializer list as much as possible, and only use the constructor body for non-assignment operations and assignments where the initializer list cannot be used or is otherwise insufficient.
C++ allows more than one constructor. The other constructors must have different parameters. Additionally constructors which contain parameters which are given default values, must adhere to the restriction that not all parameters are given a default value. This is a situation which only matters if there is a default constructor. The constructor of a base class (or base classes) can also be called by a derived class. Constructor functions are not inherited and their addresses cannot be referenced. When memory allocation is required, the new and delete operators are called implicitly.
A copy constructor has a parameter of the same type passed as const reference, for example X(const X& rhs). If it is not provided explicitly, the compiler uses the copy constructor for each member variable or simply copies values in case of primitive types. The default implementation is not efficient if the class has dynamically allocated members (or handles to other resources), because it can lead to double calls to delete (or double release of resources) upon destruction.
<span id="mwAcM"></span><span class="k" id="mwAcQ">import</span><span class="w" id="mwAcU"> </span><span class="n" id="mwAcY">std</span><span class="p" id="mwAcc">;</span> <span class="k" id="mwAcg">class</span><span class="w" id="mwAck"> </span><span class="nc" id="mwAco">PolarPoint</span><span class="w" id="mwAcs"> </span><span class="p" id="mwAcw">{</span> <span class="k" id="mwAc0">private</span><span class="o" id="mwAc4">:</span> <span class="w" id="mwAc8"> </span><span class="kt" id="mwAdA">double</span><span class="w" id="mwAdE"> </span><span class="n" id="mwAdI">x</span><span class="p" id="mwAdM">;</span> <span class="w" id="mwAdQ"> </span><span class="kt" id="mwAdU">double</span><span class="w" id="mwAdY"> </span><span class="n" id="mwAdc">y</span><span class="p" id="mwAdg">;</span> <span class="k" id="mwAdk">public</span><span class="o" id="mwAdo">:</span> <span class="w" id="mwAds"> </span><span class="k" id="mwAdw">explicit</span><span class="w" id="mwAd0"> </span><span class="n" id="mwAd4">PolarPoint</span><span class="p" id="mwAd8">(</span><span class="kt" id="mwAeA">double</span><span class="w" id="mwAeE"> </span><span class="n" id="mwAeI">r</span><span class="w" id="mwAeM"> </span><span class="o" id="mwAeQ">=</span><span class="w" id="mwAeU"> </span><span class="mf" id="mwAeY">1.0</span><span class="p" id="mwAec">,</span><span class="w" id="mwAeg"> </span><span class="kt" id="mwAek">double</span><span class="w" id="mwAeo"> </span><span class="n" id="mwAes">theta</span><span class="w" id="mwAew"> </span><span class="o" id="mwAe0">=</span><span class="w" id="mwAe4"> </span><span class="mf" id="mwAe8">0.0</span><span class="p" id="mwAfA">)</span><span class="o" id="mwAfE">:</span><span class="w" id="mwAfI"> </span><span class="c1" id="mwAfM">// Constructor, parameters with default values.</span> <span class="w" id="mwAfQ"> </span><span class="n" id="mwAfU">x</span><span class="p" id="mwAfY">{</span><span class="n" id="mwAfc">r</span><span class="w" id="mwAfg"> </span><span class="o" id="mwAfk">*</span><span class="w" id="mwAfo"> </span><span class="nf" id="mwAfs">std::cos</span><span class="p" id="mwAfw">(</span><span class="n" id="mwAf0">theta</span><span class="p" id="mwAf4">)},</span><span class="w" id="mwAf8"> </span><span class="n" id="mwAgA">y</span><span class="p" id="mwAgE">{</span><span class="n" id="mwAgI">r</span><span class="w" id="mwAgM"> </span><span class="o" id="mwAgQ">*</span><span class="w" id="mwAgU"> </span><span class="n" id="mwAgY">std</span><span class="o" id="mwAgc">::</span><span class="n" id="mwAgg">sin</span><span class="p" id="mwAgk">(</span><span class="n" id="mwAgo">theta</span><span class="p" id="mwAgs">)}</span><span class="w" id="mwAgw"> </span><span class="cm" id="mwAg0">/* <- Initializer list */</span><span class="w" id="mwAg4"> </span><span class="p" id="mwAg8">{</span> <span class="w" id="mwAhA"> </span><span class="n" id="mwAhE">std</span><span class="o" id="mwAhI">::</span><span class="n" id="mwAhM">println</span><span class="p" id="mwAhQ">(</span><span class="s" id="mwAhU">"Point: x = {}, y = {}"</span><span class="p" id="mwAhY">,</span><span class="w" id="mwAhc"> </span><span class="n" id="mwAhg">x</span><span class="p" id="mwAhk">,</span><span class="w" id="mwAho"> </span><span class="n" id="mwAhs">y</span><span class="p" id="mwAhw">);</span><span class="w" id="mwAh0"> </span><span class="c1" id="mwAh4">// Constructor body</span> <span class="w" id="mwAh8"> </span><span class="p" id="mwAiA">}</span> <span class="p" id="mwAiE">};</span>Example invocations:
<span id="mwAiU"></span><span class="n" id="mwAiY">PolarPoint</span><span class="w" id="mwAic"> </span><span class="n" id="mwAig">a</span><span class="p" id="mwAik">;</span> <span class="n" id="mwAio">PolarPoint</span><span class="w" id="mwAis"> </span><span class="nf" id="mwAiw">b</span><span class="p" id="mwAi0">(</span><span class="mi" id="mwAi4">3</span><span class="p" id="mwAi8">);</span> <span class="n" id="mwAjA">PolarPoint</span><span class="w" id="mwAjE"> </span><span class="nf" id="mwAjI">c</span><span class="p" id="mwAjM">(</span><span class="mi" id="mwAjQ">5</span><span class="p" id="mwAjU">,</span><span class="w" id="mwAjY"> </span><span class="n" id="mwAjc">std</span><span class="o" id="mwAjg">::</span><span class="n" id="mwAjk">numbers</span><span class="o" id="mwAjo">::</span><span class="n" id="mwAjs">pi</span><span class="w" id="mwAjw"> </span><span class="o" id="mwAj0">/</span><span class="w" id="mwAj4"> </span><span class="mi" id="mwAj8">4</span><span class="p" id="mwAkA">);</span>
On returning objects from functions or passing objects by value, the objects copy constructor will be called implicitly, unless return value optimization applies.
C++ implicitly generates a default copy constructor which will call the copy constructors for all base classes and all member variables unless the programmer provides one, explicitly deletes the copy constructor (to prevent cloning) or one of the base classes or member variables copy constructor is deleted or not accessible (private). Most cases calling for a customized copy constructor (e.g. reference counting, deep copy of pointers) also require customizing the destructor and the copy assignment operator. This is commonly referred to as the Rule of three.
C#
Example C# constructor:
<span id="mwAk8"></span><span class="k" id="mwAlA">public</span><span class="w" id="mwAlE"> </span><span class="k" id="mwAlI">class</span><span class="w" id="mwAlM"> </span><span class="nc" id="mwAlQ">MyClass</span> <span class="p" id="mwAlU">{</span> <span class="w" id="mwAlY"> </span><span class="k" id="mwAlc">private</span><span class="w" id="mwAlg"> </span><span class="kt" id="mwAlk">int</span><span class="w" id="mwAlo"> </span><span class="n" id="mwAls">a</span><span class="p" id="mwAlw">;</span> <span class="w" id="mwAl0"> </span><span class="k" id="mwAl4">private</span><span class="w" id="mwAl8"> </span><span class="kt" id="mwAmA">string</span><span class="w" id="mwAmE"> </span><span class="n" id="mwAmI">b</span><span class="p" id="mwAmM">;</span> <span class="w" id="mwAmQ"> </span><span class="c1" id="mwAmU">// Constructor</span> <span class="w" id="mwAmY"> </span><span class="k" id="mwAmc">public</span><span class="w" id="mwAmg"> </span><span class="nf" id="mwAmk">MyClass</span><span class="p" id="mwAmo">()</span><span class="w" id="mwAms"> </span><span class="p" id="mwAmw">:</span><span class="w" id="mwAm0"> </span><span class="k" id="mwAm4">this</span><span class="p" id="mwAm8">(</span><span class="mi" id="mwAnA">42</span><span class="p" id="mwAnE">,</span><span class="w" id="mwAnI"> </span><span class="s" id="mwAnM">"string"</span><span class="p" id="mwAnQ">)</span> <span class="w" id="mwAnU"> </span><span class="p" id="mwAnY">{</span> <span class="w" id="mwAnc"> </span><span class="p" id="mwAng">}</span> <span class="w" id="mwAnk"> </span><span class="c1" id="mwAno">// Overloading a constructor</span> <span class="w" id="mwAns"> </span><span class="k" id="mwAnw">public</span><span class="w" id="mwAn0"> </span><span class="nf" id="mwAn4">MyClass</span><span class="p" id="mwAn8">(</span><span class="kt" id="mwAoA">int</span><span class="w" id="mwAoE"> </span><span class="n" id="mwAoI">a</span><span class="p" id="mwAoM">,</span><span class="w" id="mwAoQ"> </span><span class="kt" id="mwAoU">string</span><span class="w" id="mwAoY"> </span><span class="n" id="mwAoc">b</span><span class="p" id="mwAog">)</span> <span class="w" id="mwAok"> </span><span class="p" id="mwAoo">{</span> <span class="w" id="mwAos"> </span><span class="k" id="mwAow">this</span><span class="p" id="mwAo0">.</span><span class="n" id="mwAo4">a</span><span class="w" id="mwAo8"> </span><span class="o" id="mwApA">=</span><span class="w" id="mwApE"> </span><span class="n" id="mwApI">a</span><span class="p" id="mwApM">;</span> <span class="w" id="mwApQ"> </span><span class="k" id="mwApU">this</span><span class="p" id="mwApY">.</span><span class="n" id="mwApc">b</span><span class="w" id="mwApg"> </span><span class="o" id="mwApk">=</span><span class="w" id="mwApo"> </span><span class="n" id="mwAps">b</span><span class="p" id="mwApw">;</span> <span class="w" id="mwAp0"> </span><span class="p" id="mwAp4">}</span> <span class="p" id="mwAp8">}</span><span id="mwAqI"></span><span class="c1" id="mwAqM">// Code somewhere</span> <span class="c1" id="mwAqQ">// Instantiating an object with the constructor above</span> <span class="n" id="mwAqU">MyClass</span><span class="w" id="mwAqY"> </span><span class="n" id="mwAqc">c</span><span class="w" id="mwAqg"> </span><span class="o" id="mwAqk">=</span><span class="w" id="mwAqo"> </span><span class="k" id="mwAqs">new</span><span class="w" id="mwAqw"> </span><span class="n" id="mwAq0">MyClass</span><span class="p" id="mwAq4">(</span><span class="mi" id="mwAq8">42</span><span class="p" id="mwArA">,</span><span class="w" id="mwArE"> </span><span class="s" id="mwArI">"string"</span><span class="p" id="mwArM">);</span>
Since C# 9.0, constructor calls can be further simplified using target-typed new expressions, which do not require naming the constructor when the type is already given. It will automatically call the constructor of the named type before the variable, but obviously will not resolve if using type deduction (var).
<span id="mwAr0"></span><span class="c1" id="mwAr4">// Above example with target-typed new expressions</span> <span class="n" id="mwAr8">MyClass</span><span class="w" id="mwAsA"> </span><span class="n" id="mwAsE">c</span><span class="w" id="mwAsI"> </span><span class="o" id="mwAsM">=</span><span class="w" id="mwAsQ"> </span><span class="k" id="mwAsU">new</span><span class="p" id="mwAsY">(</span><span class="mi" id="mwAsc">42</span><span class="p" id="mwAsg">,</span><span class="w" id="mwAsk"> </span><span class="s" id="mwAso">"string"</span><span class="p" id="mwAss">);</span>
C# static constructor
In C#, a static constructor is a static data initializer. Static constructors are also called class constructors. Since the actual method generated has the name .cctor they are often also called "cctors".
Static constructors allow complex static variable initialization. Static constructors are called implicitly when the class is first accessed. Any call to a class (static or constructor call), triggers the static constructor execution. Static constructors are thread safe and implement a singleton pattern. When used in a generic programming class, static constructors are called at every new generic instantiation one per type. Static variables are instantiated as well.
<span id="mwAvQ"></span><span class="k" id="mwAvU">public</span><span class="w" id="mwAvY"> </span><span class="k" id="mwAvc">class</span><span class="w" id="mwAvg"> </span><span class="nc" id="mwAvk">MyClass</span> <span class="p" id="mwAvo">{</span> <span class="w" id="mwAvs"> </span><span class="k" id="mwAvw">private</span><span class="w" id="mwAv0"> </span><span class="k" id="mwAv4">static</span><span class="w" id="mwAv8"> </span><span class="kt" id="mwAwA">int</span><span class="w" id="mwAwE"> </span><span class="n" id="mwAwI">_A</span><span class="p" id="mwAwM">;</span> <span class="w" id="mwAwQ"> </span><span class="c1" id="mwAwU">// Normal constructor</span> <span class="w" id="mwAwY"> </span><span class="k" id="mwAwc">static</span><span class="w" id="mwAwg"> </span><span class="nf" id="mwAwk">MyClass</span><span class="p" id="mwAwo">()</span> <span class="w" id="mwAws"> </span><span class="p" id="mwAww">{</span> <span class="w" id="mwAw0"> </span><span class="n" id="mwAw4">_A</span><span class="w" id="mwAw8"> </span><span class="o" id="mwAxA">=</span><span class="w" id="mwAxE"> </span><span class="mi" id="mwAxI">32</span><span class="p" id="mwAxM">;</span> <span class="w" id="mwAxQ"> </span><span class="p" id="mwAxU">}</span> <span class="w" id="mwAxY"> </span><span class="c1" id="mwAxc">// Standard default constructor</span> <span class="w" id="mwAxg"> </span><span class="k" id="mwAxk">public</span><span class="w" id="mwAxo"> </span><span class="nf" id="mwAxs">MyClass</span><span class="p" id="mwAxw">()</span> <span class="w" id="mwAx0"> </span><span class="p" id="mwAx4">{</span> <span class="w" id="mwAx8"> </span><span class="p" id="mwAyA">}</span> <span class="p" id="mwAyE">}</span><span id="mwAyQ"></span><span class="c1" id="mwAyU">// Code somewhere</span> <span class="c1" id="mwAyY">// Instantiating an object with the constructor above</span> <span class="c1" id="mwAyc">// right before the instantiation</span> <span class="c1" id="mwAyg">// The variable static constructor is executed and _A is 32</span> <span class="n" id="mwAyk">MyClass</span><span class="w" id="mwAyo"> </span><span class="n" id="mwAys">c</span><span class="w" id="mwAyw"> </span><span class="o" id="mwAy0">=</span><span class="w" id="mwAy4"> </span><span class="k" id="mwAy8">new</span><span class="w" id="mwAzA"> </span><span class="n" id="mwAzE">MyClass</span><span class="p" id="mwAzI">();</span>
ColdFusion Markup Language (CFML)
ColdFusion Markup Language (CFML) uses a method named 'init' as a constructor method.
Cheese.cfc
<span id="mwAzs"></span><span class="k" id="mwAzw">component</span> <span class="p" id="mwAz0">{</span> <span class="c1" id="mwAz4">// properties</span> <span class="k" id="mwAz8">property</span> <span class="nv" id="mwA0A">name</span><span class="o" id="mwA0E">=</span><span class="s2" id="mwA0I">"cheeseName"</span><span class="p" id="mwA0M">;</span> <span class="c1" id="mwA0Q">// constructor</span> <span class="k" id="mwA0U">function</span> <span class="nv" id="mwA0Y">Cheese</span> <span class="nf" id="mwA0c">init</span><span class="p" id="mwA0g">(</span> <span class="k" id="mwA0k">required</span> <span class="k" id="mwA0o">string</span> <span class="nv" id="mwA0s">cheeseName</span> <span class="p" id="mwA0w">)</span> <span class="p" id="mwA00">{</span> <span class="no" id="mwA04">variables</span><span class="p" id="mwA08">.</span><span class="nv" id="mwA1A">cheeseName</span> <span class="o" id="mwA1E">=</span> <span class="no" id="mwA1I">arguments</span><span class="p" id="mwA1M">.</span><span class="nv" id="mwA1Q">cheeseName</span><span class="p" id="mwA1U">;</span> <span class="k" id="mwA1Y">return</span> <span class="no" id="mwA1c">this</span><span class="p" id="mwA1g">;</span> <span class="p" id="mwA1k">}</span> <span class="p" id="mwA1o">}</span>Create instance of a cheese.
<span id="mwA14"></span><span class="nv" id="mwA18">myCheese</span> <span class="o" id="mwA2A">=</span> <span class="nv" id="mwA2E">new</span> <span class="nf" id="mwA2I">Cheese</span><span class="p" id="mwA2M">(</span> <span class="s1" id="mwA2Q">'Cheddar'</span> <span class="p" id="mwA2U">);</span>
Since ColdFusion 10, CFML has also supported specifying the name of the constructor method:
<span id="mwA20"></span><span class="k" id="mwA24">component</span> <span class="nv" id="mwA28">initmethod</span><span class="o" id="mwA3A">=</span><span class="s2" id="mwA3E">"Cheese"</span> <span class="p" id="mwA3I">{</span> <span class="c1" id="mwA3M">// properties</span> <span class="k" id="mwA3Q">property</span> <span class="nv" id="mwA3U">name</span><span class="o" id="mwA3Y">=</span><span class="s2" id="mwA3c">"cheeseName"</span><span class="p" id="mwA3g">;</span> <span class="c1" id="mwA3k">// constructor</span> <span class="k" id="mwA3o">function</span> <span class="nv" id="mwA3s">Cheese</span> <span class="nf" id="mwA3w">Cheese</span><span class="p" id="mwA30">(</span> <span class="k" id="mwA34">required</span> <span class="k" id="mwA38">string</span> <span class="nv" id="mwA4A">cheeseName</span> <span class="p" id="mwA4E">)</span> <span class="p" id="mwA4I">{</span> <span class="no" id="mwA4M">variables</span><span class="p" id="mwA4Q">.</span><span class="nv" id="mwA4U">cheeseName</span> <span class="o" id="mwA4Y">=</span> <span class="no" id="mwA4c">arguments</span><span class="p" id="mwA4g">.</span><span class="nv" id="mwA4k">cheeseName</span><span class="p" id="mwA4o">;</span> <span class="k" id="mwA4s">return</span> <span class="no" id="mwA4w">this</span><span class="p" id="mwA40">;</span> <span class="p" id="mwA44">}</span> <span class="p" id="mwA48">}</span>Crystal
In Crystal, the user defines an initialize method, which the compiler uses to define a new method for allocating memory for the object and calling the user-defined method. The user can also manually define new or define an equivalent method with a different name, if desired (the code for both initialize and new is shown here). Although this snippet defines a class, the procedure is identical for Crystal structs.
<span id="mwA5s"></span><span class="k" id="mwA5w">class</span><span class="w" id="mwA50"> </span><span class="nc" id="mwA54">Car</span> <span class="w" id="mwA58"> </span><span class="c1" id="mwA6A"># the initializer, which is an instance method.</span> <span class="w" id="mwA6E"> </span><span class="k" id="mwA6I">def</span><span class="w" id="mwA6M"> </span><span class="nf" id="mwA6Q">initialize</span><span class="p" id="mwA6U">(</span><span class="n" id="mwA6Y">make</span><span class="w" id="mwA6c"> </span><span class="p" id="mwA6g">:</span><span class="w" id="mwA6k"> </span><span class="n" id="mwA6o">String</span><span class="p" id="mwA6s">,</span><span class="w" id="mwA6w"> </span><span class="n" id="mwA60">year</span><span class="w" id="mwA64"> </span><span class="p" id="mwA68">:</span><span class="w" id="mwA7A"> </span><span class="n" id="mwA7E">Int</span><span class="p" id="mwA7I">)</span> <span class="w" id="mwA7M"> </span><span class="vi" id="mwA7Q">@make</span><span class="w" id="mwA7U"> </span><span class="o" id="mwA7Y">=</span><span class="w" id="mwA7c"> </span><span class="n" id="mwA7g">make</span> <span class="w" id="mwA7k"> </span><span class="vi" id="mwA7o">@year</span><span class="w" id="mwA7s"> </span><span class="o" id="mwA7w">=</span><span class="w" id="mwA70"> </span><span class="n" id="mwA74">year</span> <span class="w" id="mwA78"> </span><span class="k" id="mwA8A">end</span> <span class="w" id="mwA8E"> </span><span class="c1" id="mwA8I"># the allocator, which is a class method, denoted by the "self." prefix.</span> <span class="w" id="mwA8M"> </span><span class="c1" id="mwA8Q"># note that `new` takes the same arguments as `initialize`</span> <span class="w" id="mwA8U"> </span><span class="k" id="mwA8Y">def</span><span class="w" id="mwA8c"> </span><span class="nc" id="mwA8g">self</span><span class="o" id="mwA8k">.</span><span class="nf" id="mwA8o">new</span><span class="p" id="mwA8s">(</span><span class="n" id="mwA8w">make</span><span class="w" id="mwA80"> </span><span class="p" id="mwA84">:</span><span class="w" id="mwA88"> </span><span class="n" id="mwA9A">String</span><span class="p" id="mwA9E">,</span><span class="w" id="mwA9I"> </span><span class="n" id="mwA9M">year</span><span class="w" id="mwA9Q"> </span><span class="p" id="mwA9U">:</span><span class="w" id="mwA9Y"> </span><span class="n" id="mwA9c">Int</span><span class="p" id="mwA9g">)</span> <span class="w" id="mwA9k"> </span><span class="c1" id="mwA9o"># allocate memory for the instance</span> <span class="w" id="mwA9s"> </span><span class="n" id="mwA9w">instance</span><span class="w" id="mwA90"> </span><span class="o" id="mwA94">=</span><span class="w" id="mwA98"> </span><span class="n" id="mwA-A">Car</span><span class="o" id="mwA-E">.</span><span class="n" id="mwA-I">allocate</span> <span class="w" id="mwA-M"> </span><span class="c1" id="mwA-Q"># call the instance's initialize method using the provided parameters</span> <span class="w" id="mwA-U"> </span><span class="n" id="mwA-Y">instance</span><span class="o" id="mwA-c">.</span><span class="n" id="mwA-g">initialize</span><span class="w" id="mwA-k"> </span><span class="n" id="mwA-o">make</span><span class="p" id="mwA-s">,</span><span class="w" id="mwA-w"> </span><span class="n" id="mwA-0">year</span> <span class="w" id="mwA-4"> </span><span class="c1" id="mwA-8"># return the instance</span> <span class="w" id="mwA_A"> </span><span class="n" id="mwA_E">instance</span> <span class="w" id="mwA_I"> </span><span class="k" id="mwA_M">end</span> <span class="k" id="mwA_Q">end</span> <span class="c1" id="mwA_U"># instantiate a new `Car` like so:</span> <span class="n" id="mwA_Y">old_car</span><span class="w" id="mwA_c"> </span><span class="o" id="mwA_g">=</span><span class="w" id="mwA_k"> </span><span class="n" id="mwA_o">Car</span><span class="o" id="mwA_s">.</span><span class="n" id="mwA_w">new</span><span class="p" id="mwA_0">(</span><span class="s2" id="mwA_4">"Chevrolet"</span><span class="p" id="mwA_8">,</span><span class="w" id="mwBAA"> </span><span class="mi" id="mwBAE">1947</span><span class="p" id="mwBAI">)</span>
Eiffel
In Eiffel, the routines which initialize new objects are called creation procedures. Creation procedures have the following traits:
- Creation procedures have no explicit return type (by definition of procedure).
- Creation procedures are named.
- Creation procedures are designated by name as creation procedures in the text of the class.
- Creation procedures can be explicitly invoked to re-initialize existing objects.
- Every effective (i.e., concrete or non-abstract) class must designate at least one creation procedure.
- Creation procedures must leave the newly initialized object in a state that satisfies the class invariant.
Although object creation involves some subtleties, the creation of an attribute with a typical declaration x: T as expressed in a creation instruction create x.make consists of the following sequence of steps:
- Create a new direct instance of type
T. - Execute the creation procedure
maketo the newly created instance. - Attach the newly initialized object to the entity
x.
In the first snippet below, class POINT is defined. The procedure make is coded after the keyword feature.
The keyword create introduces a list of procedures which can be used to initialize instances. In this case the list includes default_create, a procedure with an empty implementation inherited from class ANY, and the make procedure coded within the class.
<span id="mwBDQ"></span><span class="kr" id="mwBDU">class</span> <span class="w" id="mwBDY"> </span><span class="nc" id="mwBDc">POINT</span> <span class="kr" id="mwBDg">create</span> <span class="w" id="mwBDk"> </span><span class="n" id="mwBDo">default_create</span><span class="p" id="mwBDs">,</span><span class="w" id="mwBDw"> </span><span class="n" id="mwBD0">make</span> <span class="kr" id="mwBD4">feature</span> <span class="w" id="mwBD8"> </span><span class="n" id="mwBEA">make</span><span class="w" id="mwBEE"> </span><span class="p" id="mwBEI">(</span><span class="n" id="mwBEM">a_x_value</span><span class="p" id="mwBEQ">:</span><span class="w" id="mwBEU"> </span><span class="nc" id="mwBEY">REAL</span><span class="p" id="mwBEc">;</span><span class="w" id="mwBEg"> </span><span class="n" id="mwBEk">a_y_value</span><span class="p" id="mwBEo">:</span><span class="w" id="mwBEs"> </span><span class="nc" id="mwBEw">REAL</span><span class="p" id="mwBE0">)</span> <span class="w" id="mwBE4"> </span><span class="kr" id="mwBE8">do</span> <span class="w" id="mwBFA"> </span><span class="n" id="mwBFE">x</span><span class="w" id="mwBFI"> </span><span class="o" id="mwBFM">:=</span><span class="w" id="mwBFQ"> </span><span class="n" id="mwBFU">a_x_value</span> <span class="w" id="mwBFY"> </span><span class="n" id="mwBFc">y</span><span class="w" id="mwBFg"> </span><span class="o" id="mwBFk">:=</span><span class="w" id="mwBFo"> </span><span class="n" id="mwBFs">a_y_value</span> <span class="w" id="mwBFw"> </span><span class="kr" id="mwBF0">end</span> <span class="w" id="mwBF4"> </span><span class="n" id="mwBF8">x</span><span class="p" id="mwBGA">:</span><span class="w" id="mwBGE"> </span><span class="nc" id="mwBGI">REAL</span> <span class="w" id="mwBGM"> </span><span class="c1" id="mwBGQ">-- X coordinate</span> <span class="w" id="mwBGU"> </span><span class="n" id="mwBGY">y</span><span class="p" id="mwBGc">:</span><span class="w" id="mwBGg"> </span><span class="nc" id="mwBGk">REAL</span> <span class="w" id="mwBGo"> </span><span class="c1" id="mwBGs">-- Y coordinate</span> <span class="w" id="mwBGw"> </span><span class="p" id="mwBG0">...</span>
In the second snippet, a class which is a client to POINT has a declarations my_point_1 and my_point_2 of type POINT.
In procedural code, my_point_1 is created as the origin (0.0, 0.0). Because no creation procedure is specified, the procedure default_create inherited from class ANY is used. This line could have been coded create my_point_1.default_create . Only procedures named as creation procedures can be used in an instruction with the create keyword. Next is a creation instruction for my_point_2, providing initial values for the my_point_2's coordinates. The third instruction makes an ordinary instance call to the make procedure to reinitialize the instance attached to my_point_2 with different values.
<span id="mwBH8"></span><span class="w" id="mwBIA"> </span><span class="n" id="mwBIE">my_point_1</span><span class="p" id="mwBII">:</span><span class="w" id="mwBIM"> </span><span class="nc" id="mwBIQ">POINT</span> <span class="w" id="mwBIU"> </span><span class="n" id="mwBIY">my_point_2</span><span class="p" id="mwBIc">:</span><span class="w" id="mwBIg"> </span><span class="nc" id="mwBIk">POINT</span> <span class="w" id="mwBIo"> </span><span class="p" id="mwBIs">...</span> <span class="w" id="mwBIw"> </span><span class="kr" id="mwBI0">create</span><span class="w" id="mwBI4"> </span><span class="n" id="mwBI8">my_point_1</span> <span class="w" id="mwBJA"> </span><span class="kr" id="mwBJE">create</span><span class="w" id="mwBJI"> </span><span class="n" id="mwBJM">my_point_2</span><span class="p" id="mwBJQ">.</span><span class="n" id="mwBJU">make</span><span class="w" id="mwBJY"> </span><span class="p" id="mwBJc">(</span><span class="mf" id="mwBJg">3.0</span><span class="p" id="mwBJk">,</span><span class="w" id="mwBJo"> </span><span class="mf" id="mwBJs">4.0</span><span class="p" id="mwBJw">)</span> <span class="w" id="mwBJ0"> </span><span class="n" id="mwBJ4">my_point_2</span><span class="p" id="mwBJ8">.</span><span class="n" id="mwBKA">make</span><span class="w" id="mwBKE"> </span><span class="p" id="mwBKI">(</span><span class="mf" id="mwBKM">5.0</span><span class="p" id="mwBKQ">,</span><span class="w" id="mwBKU"> </span><span class="mf" id="mwBKY">8.0</span><span class="p" id="mwBKc">)</span> <span class="w" id="mwBKg"> </span><span class="p" id="mwBKk">...</span>
F#
In F#, a constructor can include any let or do statements defined in a class. let statements define private fields and do statements execute code. Additional constructors can be defined using the new keyword.
<span id="mwBLQ"></span><span class="k" id="mwBLU">type</span><span class="w" id="mwBLY"> </span><span class="nc" id="mwBLc">MyClass</span><span class="o" id="mwBLg">(_</span><span class="n" id="mwBLk">a</span><span class="w" id="mwBLo"> </span><span class="o" id="mwBLs">:</span><span class="w" id="mwBLw"> </span><span class="n" id="mwBL0">int</span><span class="o" id="mwBL4">,</span><span class="w" id="mwBL8"> </span><span class="o" id="mwBMA">_</span><span class="n" id="mwBME">b</span><span class="w" id="mwBMI"> </span><span class="o" id="mwBMM">:</span><span class="w" id="mwBMQ"> </span><span class="kt" id="mwBMU">string</span><span class="o" id="mwBMY">)</span><span class="w" id="mwBMc"> </span><span class="o" id="mwBMg">=</span><span class="w" id="mwBMk"> </span><span class="k" id="mwBMo">class</span> <span class="w" id="mwBMs"> </span><span class="c1" id="mwBMw">// Primary constructor</span> <span class="w" id="mwBM0"> </span><span class="k" id="mwBM4">let</span><span class="w" id="mwBM8"> </span><span class="nv" id="mwBNA">a</span><span class="w" id="mwBNE"> </span><span class="o" id="mwBNI">=</span><span class="w" id="mwBNM"> </span><span class="o" id="mwBNQ">_</span><span class="n" id="mwBNU">a</span> <span class="w" id="mwBNY"> </span><span class="k" id="mwBNc">let</span><span class="w" id="mwBNg"> </span><span class="nv" id="mwBNk">b</span><span class="w" id="mwBNo"> </span><span class="o" id="mwBNs">=</span><span class="w" id="mwBNw"> </span><span class="o" id="mwBN0">_</span><span class="n" id="mwBN4">b</span> <span class="w" id="mwBN8"> </span><span class="k" id="mwBOA">do</span><span class="w" id="mwBOE"> </span><span class="n" id="mwBOI">printfn</span><span class="w" id="mwBOM"> </span><span class="s" id="mwBOQ">"a = %i, b = %s"</span><span class="w" id="mwBOU"> </span><span class="n" id="mwBOY">a</span><span class="w" id="mwBOc"> </span><span class="n" id="mwBOg">b</span> <span class="w" id="mwBOk"> </span><span class="c1" id="mwBOo">// Additional constructors</span> <span class="w" id="mwBOs"> </span><span class="k" id="mwBOw">new</span><span class="o" id="mwBO0">(_</span><span class="n" id="mwBO4">a</span><span class="w" id="mwBO8"> </span><span class="o" id="mwBPA">:</span><span class="w" id="mwBPE"> </span><span class="n" id="mwBPI">int</span><span class="o" id="mwBPM">)</span><span class="w" id="mwBPQ"> </span><span class="o" id="mwBPU">=</span><span class="w" id="mwBPY"> </span><span class="n" id="mwBPc">MyClass</span><span class="o" id="mwBPg">(_</span><span class="n" id="mwBPk">a</span><span class="o" id="mwBPo">,</span><span class="w" id="mwBPs"> </span><span class="s" id="mwBPw">""</span><span class="o" id="mwBP0">)</span><span class="w" id="mwBP4"> </span><span class="k" id="mwBP8">then</span> <span class="w" id="mwBQA"> </span><span class="n" id="mwBQE">printfn</span><span class="w" id="mwBQI"> </span><span class="s" id="mwBQM">"Integer parameter given"</span> <span class="w" id="mwBQQ"> </span><span class="k" id="mwBQU">new</span><span class="o" id="mwBQY">(_</span><span class="n" id="mwBQc">b</span><span class="w" id="mwBQg"> </span><span class="o" id="mwBQk">:</span><span class="w" id="mwBQo"> </span><span class="kt" id="mwBQs">string</span><span class="o" id="mwBQw">)</span><span class="w" id="mwBQ0"> </span><span class="o" id="mwBQ4">=</span><span class="w" id="mwBQ8"> </span><span class="n" id="mwBRA">MyClass</span><span class="o" id="mwBRE">(</span><span class="mi" id="mwBRI">0</span><span class="o" id="mwBRM">,</span><span class="w" id="mwBRQ"> </span><span class="o" id="mwBRU">_</span><span class="n" id="mwBRY">b</span><span class="o" id="mwBRc">)</span><span class="w" id="mwBRg"> </span><span class="k" id="mwBRk">then</span> <span class="w" id="mwBRo"> </span><span class="n" id="mwBRs">printfn</span><span class="w" id="mwBRw"> </span><span class="s" id="mwBR0">"String parameter given"</span> <span class="w" id="mwBR4"> </span><span class="k" id="mwBR8">new</span><span class="bp" id="mwBSA">()</span><span class="w" id="mwBSE"> </span><span class="o" id="mwBSI">=</span><span class="w" id="mwBSM"> </span><span class="n" id="mwBSQ">MyClass</span><span class="o" id="mwBSU">(</span><span class="mi" id="mwBSY">0</span><span class="o" id="mwBSc">,</span><span class="w" id="mwBSg"> </span><span class="s" id="mwBSk">""</span><span class="o" id="mwBSo">)</span><span class="w" id="mwBSs"> </span><span class="k" id="mwBSw">then</span> <span class="w" id="mwBS0"> </span><span class="n" id="mwBS4">printfn</span><span class="w" id="mwBS8"> </span><span class="s" id="mwBTA">"No parameter given"</span> <span class="k" id="mwBTE">end</span>
<span id="mwBTQ"></span><span class="c1" id="mwBTU">// Code somewhere</span> <span class="c1" id="mwBTY">// instantiating an object with the primary constructor</span> <span class="k" id="mwBTc">let</span><span class="w" id="mwBTg"> </span><span class="nv" id="mwBTk">c1</span><span class="w" id="mwBTo"> </span><span class="o" id="mwBTs">=</span><span class="w" id="mwBTw"> </span><span class="k" id="mwBT0">new</span><span class="w" id="mwBT4"> </span><span class="n" id="mwBT8">MyClass</span><span class="o" id="mwBUA">(</span><span class="mi" id="mwBUE">42</span><span class="o" id="mwBUI">,</span><span class="w" id="mwBUM"> </span><span class="s" id="mwBUQ">"string"</span><span class="o" id="mwBUU">)</span> <span class="c1" id="mwBUY">// instantiating an object with additional constructors</span> <span class="k" id="mwBUc">let</span><span class="w" id="mwBUg"> </span><span class="nv" id="mwBUk">c2</span><span class="w" id="mwBUo"> </span><span class="o" id="mwBUs">=</span><span class="w" id="mwBUw"> </span><span class="k" id="mwBU0">new</span><span class="w" id="mwBU4"> </span><span class="n" id="mwBU8">MyClass</span><span class="o" id="mwBVA">(</span><span class="mi" id="mwBVE">42</span><span class="o" id="mwBVI">)</span> <span class="k" id="mwBVM">let</span><span class="w" id="mwBVQ"> </span><span class="nv" id="mwBVU">c3</span><span class="w" id="mwBVY"> </span><span class="o" id="mwBVc">=</span><span class="w" id="mwBVg"> </span><span class="k" id="mwBVk">new</span><span class="w" id="mwBVo"> </span><span class="n" id="mwBVs">MyClass</span><span class="o" id="mwBVw">(</span><span class="s" id="mwBV0">"string"</span><span class="o" id="mwBV4">)</span> <span class="k" id="mwBV8">let</span><span class="w" id="mwBWA"> </span><span class="nv" id="mwBWE">c4</span><span class="w" id="mwBWI"> </span><span class="o" id="mwBWM">=</span><span class="w" id="mwBWQ"> </span><span class="n" id="mwBWU">MyClass</span><span class="bp" id="mwBWY">()</span><span class="w" id="mwBWc"> </span><span class="c1" id="mwBWg">// "new" keyword is optional</span>
Java
In Java, constructors differ from other methods in that:
- Constructors never have an explicit return type.
- Constructors cannot be directly invoked (the keyword “
new” invokes them). - Constructors should not have non-access modifiers.
Java constructors perform the following tasks in the following order:
- Call the default constructor of the superclass if no constructor is defined.
- Initialize member variables to the specified values.
- Executes the body of the constructor.
Java permit users to call one constructor in another constructor using this() keyword. But this() must be first statement.
<span id="mwBX8"></span><span class="kd" id="mwBYA">class</span> <span class="nc" id="mwBYE">X</span><span class="w" id="mwBYI"> </span><span class="p" id="mwBYM">{</span><span class="w" id="mwBYQ"> </span> <span class="w" id="mwBYU"> </span><span class="kd" id="mwBYY">public</span><span class="w" id="mwBYc"> </span><span class="nf" id="mwBYg">X</span><span class="p" id="mwBYk">()</span><span class="w" id="mwBYo"> </span><span class="p" id="mwBYs">{</span><span class="w" id="mwBYw"> </span><span class="c1" id="mwBY0">// Non-parameterized constructor</span> <span class="w" id="mwBY4"> </span><span class="k" id="mwBY8">this</span><span class="p" id="mwBZA">(</span><span class="mi" id="mwBZE">1</span><span class="p" id="mwBZI">);</span><span class="w" id="mwBZM"> </span><span class="c1" id="mwBZQ">// Calling of constructor</span> <span class="w" id="mwBZU"> </span><span class="n" id="mwBZY">System</span><span class="p" id="mwBZc">.</span><span class="na" id="mwBZg">out</span><span class="p" id="mwBZk">.</span><span class="na" id="mwBZo">println</span><span class="p" id="mwBZs">(</span><span class="s" id="mwBZw">"Calling default constructor"</span><span class="p" id="mwBZ0">);</span> <span class="w" id="mwBZ4"> </span><span class="p" id="mwBZ8">}</span> <span class="w" id="mwBaA"> </span><span class="kd" id="mwBaE">public</span><span class="w" id="mwBaI"> </span><span class="nf" id="mwBaM">X</span><span class="p" id="mwBaQ">(</span><span class="kt" id="mwBaU">int</span><span class="w" id="mwBaY"> </span><span class="n" id="mwBac">a</span><span class="p" id="mwBag">)</span><span class="w" id="mwBak"> </span><span class="p" id="mwBao">{</span><span class="w" id="mwBas"> </span><span class="c1" id="mwBaw">// Parameterized constructor</span> <span class="w" id="mwBa0"> </span><span class="n" id="mwBa4">System</span><span class="p" id="mwBa8">.</span><span class="na" id="mwBbA">out</span><span class="p" id="mwBbE">.</span><span class="na" id="mwBbI">println</span><span class="p" id="mwBbM">(</span><span class="s" id="mwBbQ">"Calling parameterized constructor"</span><span class="p" id="mwBbU">);</span> <span class="w" id="mwBbY"> </span><span class="p" id="mwBbc">}</span> <span class="p" id="mwBbg">}</span> <span class="kd" id="mwBbk">public</span><span class="w" id="mwBbo"> </span><span class="kd" id="mwBbs">class</span> <span class="nc" id="mwBbw">Example</span><span class="w" id="mwBb0"> </span><span class="p" id="mwBb4">{</span> <span class="w" id="mwBb8"> </span><span class="kd" id="mwBcA">public</span><span class="w" id="mwBcE"> </span><span class="kd" id="mwBcI">static</span><span class="w" id="mwBcM"> </span><span class="kt" id="mwBcQ">void</span><span class="w" id="mwBcU"> </span><span class="nf" id="mwBcY">main</span><span class="p" id="mwBcc">(</span><span class="n" id="mwBcg">String</span><span class="o" id="mwBck">[]</span><span class="w" id="mwBco"> </span><span class="n" id="mwBcs">args</span><span class="p" id="mwBcw">)</span><span class="w" id="mwBc0"> </span><span class="p" id="mwBc4">{</span> <span class="w" id="mwBc8"> </span><span class="n" id="mwBdA">X</span><span class="w" id="mwBdE"> </span><span class="n" id="mwBdI">x</span><span class="w" id="mwBdM"> </span><span class="o" id="mwBdQ">=</span><span class="w" id="mwBdU"> </span><span class="k" id="mwBdY">new</span><span class="w" id="mwBdc"> </span><span class="n" id="mwBdg">X</span><span class="p" id="mwBdk">();</span> <span class="w" id="mwBdo"> </span><span class="p" id="mwBds">}</span> <span class="p" id="mwBdw">}</span>Java provides access to the superclass's constructor through the super keyword.
<span id="mwBeI"></span><span class="kd" id="mwBeM">class</span> <span class="nc" id="mwBeQ">X</span><span class="w" id="mwBeU"> </span><span class="p" id="mwBeY">{</span> <span class="w" id="mwBec"> </span><span class="c1" id="mwBeg">// Declaration of instance variable(s).</span> <span class="w" id="mwBek"> </span><span class="kd" id="mwBeo">private</span><span class="w" id="mwBes"> </span><span class="kt" id="mwBew">int</span><span class="w" id="mwBe0"> </span><span class="n" id="mwBe4">data</span><span class="p" id="mwBe8">;</span> <span class="w" id="mwBfA"> </span><span class="c1" id="mwBfE">// Definition of the constructor.</span> <span class="w" id="mwBfI"> </span><span class="kd" id="mwBfM">public</span><span class="w" id="mwBfQ"> </span><span class="nf" id="mwBfU">X</span><span class="p" id="mwBfY">()</span><span class="w" id="mwBfc"> </span><span class="p" id="mwBfg">{</span> <span class="w" id="mwBfk"> </span><span class="k" id="mwBfo">this</span><span class="p" id="mwBfs">(</span><span class="mi" id="mwBfw">1</span><span class="p" id="mwBf0">);</span> <span class="w" id="mwBf4"> </span><span class="p" id="mwBf8">}</span> <span class="w" id="mwBgA"> </span><span class="c1" id="mwBgE">// Overloading a constructor</span> <span class="w" id="mwBgI"> </span><span class="kd" id="mwBgM">public</span><span class="w" id="mwBgQ"> </span><span class="nf" id="mwBgU">X</span><span class="p" id="mwBgY">(</span><span class="kt" id="mwBgc">int</span><span class="w" id="mwBgg"> </span><span class="n" id="mwBgk">input</span><span class="p" id="mwBgo">)</span><span class="w" id="mwBgs"> </span><span class="p" id="mwBgw">{</span> <span class="w" id="mwBg0"> </span><span class="n" id="mwBg4">data</span><span class="w" id="mwBg8"> </span><span class="o" id="mwBhA">=</span><span class="w" id="mwBhE"> </span><span class="n" id="mwBhI">input</span><span class="p" id="mwBhM">;</span><span class="w" id="mwBhQ"> </span><span class="c1" id="mwBhU">// This is an assignment</span> <span class="w" id="mwBhY"> </span><span class="p" id="mwBhc">}</span> <span class="p" id="mwBhg">}</span> <span class="kd" id="mwBhk">class</span> <span class="nc" id="mwBho">Y</span><span class="w" id="mwBhs"> </span><span class="kd" id="mwBhw">extends</span><span class="w" id="mwBh0"> </span><span class="n" id="mwBh4">X</span><span class="w" id="mwBh8"> </span><span class="p" id="mwBiA">{</span> <span class="w" id="mwBiE"> </span><span class="kd" id="mwBiI">private</span><span class="w" id="mwBiM"> </span><span class="kt" id="mwBiQ">int</span><span class="w" id="mwBiU"> </span><span class="n" id="mwBiY">data2</span><span class="p" id="mwBic">;</span> <span class="w" id="mwBig"> </span><span class="kd" id="mwBik">public</span><span class="w" id="mwBio"> </span><span class="nf" id="mwBis">Y</span><span class="p" id="mwBiw">()</span><span class="w" id="mwBi0"> </span><span class="p" id="mwBi4">{</span> <span class="w" id="mwBi8"> </span><span class="kd" id="mwBjA">super</span><span class="p" id="mwBjE">();</span> <span class="w" id="mwBjI"> </span><span class="n" id="mwBjM">data2</span><span class="w" id="mwBjQ"> </span><span class="o" id="mwBjU">=</span><span class="w" id="mwBjY"> </span><span class="mi" id="mwBjc">1</span><span class="p" id="mwBjg">;</span> <span class="w" id="mwBjk"> </span><span class="p" id="mwBjo">}</span> <span class="w" id="mwBjs"> </span><span class="kd" id="mwBjw">public</span><span class="w" id="mwBj0"> </span><span class="nf" id="mwBj4">Y</span><span class="p" id="mwBj8">(</span><span class="kt" id="mwBkA">int</span><span class="w" id="mwBkE"> </span><span class="n" id="mwBkI">input1</span><span class="p" id="mwBkM">,</span><span class="w" id="mwBkQ"> </span><span class="kt" id="mwBkU">int</span><span class="w" id="mwBkY"> </span><span class="n" id="mwBkc">input2</span><span class="p" id="mwBkg">)</span><span class="w" id="mwBkk"> </span><span class="p" id="mwBko">{</span> <span class="w" id="mwBks"> </span><span class="kd" id="mwBkw">super</span><span class="p" id="mwBk0">(</span><span class="n" id="mwBk4">input1</span><span class="p" id="mwBk8">);</span> <span class="w" id="mwBlA"> </span><span class="n" id="mwBlE">data2</span><span class="w" id="mwBlI"> </span><span class="o" id="mwBlM">=</span><span class="w" id="mwBlQ"> </span><span class="n" id="mwBlU">input2</span> <span class="w" id="mwBlY"> </span><span class="p" id="mwBlc">}</span> <span class="p" id="mwBlg">}</span> <span class="kd" id="mwBlk">public</span><span class="w" id="mwBlo"> </span><span class="kd" id="mwBls">class</span> <span class="nc" id="mwBlw">Example</span><span class="w" id="mwBl0"> </span><span class="p" id="mwBl4">{</span> <span class="w" id="mwBl8"> </span><span class="kd" id="mwBmA">public</span><span class="w" id="mwBmE"> </span><span class="kd" id="mwBmI">static</span><span class="w" id="mwBmM"> </span><span class="kt" id="mwBmQ">void</span><span class="w" id="mwBmU"> </span><span class="nf" id="mwBmY">main</span><span class="p" id="mwBmc">(</span><span class="n" id="mwBmg">String</span><span class="o" id="mwBmk">[]</span><span class="w" id="mwBmo"> </span><span class="n" id="mwBms">args</span><span class="p" id="mwBmw">)</span><span class="w" id="mwBm0"> </span><span class="p" id="mwBm4">{</span> <span class="w" id="mwBm8"> </span><span class="n" id="mwBnA">Y</span><span class="w" id="mwBnE"> </span><span class="n" id="mwBnI">y</span><span class="w" id="mwBnM"> </span><span class="o" id="mwBnQ">=</span><span class="w" id="mwBnU"> </span><span class="k" id="mwBnY">new</span><span class="w" id="mwBnc"> </span><span class="n" id="mwBng">Y</span><span class="p" id="mwBnk">(</span><span class="mi" id="mwBno">42</span><span class="p" id="mwBns">,</span><span class="w" id="mwBnw"> </span><span class="mi" id="mwBn0">43</span><span class="p" id="mwBn4">);</span> <span class="w" id="mwBn8"> </span><span class="p" id="mwBoA">}</span> <span class="p" id="mwBoE">}</span>A constructor taking zero number of arguments is called a "no-arguments" or "no-arg" constructor.
JavaScript/TypeScript
As of ES6, JavaScript has direct constructors like many other programming languages. They are written as such
<span id="mwBow"></span><span class="kd" id="mwBo0">class</span><span class="w" id="mwBo4"> </span><span class="nx" id="mwBo8">FooBar</span><span class="w" id="mwBpA"> </span><span class="p" id="mwBpE">{</span> <span class="w" id="mwBpI"> </span><span class="kr" id="mwBpM">constructor</span><span class="p" id="mwBpQ">(</span><span class="nx" id="mwBpU">baz</span><span class="p" id="mwBpY">)</span><span class="w" id="mwBpc"> </span><span class="p" id="mwBpg">{</span> <span class="w" id="mwBpk"> </span><span class="k" id="mwBpo">this</span><span class="p" id="mwBps">.</span><span class="nx" id="mwBpw">baz</span><span class="w" id="mwBp0"> </span><span class="o" id="mwBp4">=</span><span class="w" id="mwBp8"> </span><span class="nx" id="mwBqA">baz</span><span class="p" id="mwBqE">;</span> <span class="w" id="mwBqI"> </span><span class="p" id="mwBqM">}</span> <span class="p" id="mwBqQ">}</span>This can be instantiated as such
<span id="mwBqg"></span><span class="kd" id="mwBqk">const</span><span class="w" id="mwBqo"> </span><span class="nx" id="mwBqs">foo</span><span class="w" id="mwBqw"> </span><span class="o" id="mwBq0">=</span><span class="w" id="mwBq4"> </span><span class="ow" id="mwBq8">new</span><span class="w" id="mwBrA"> </span><span class="nx" id="mwBrE">FooBar</span><span class="p" id="mwBrI">(</span><span class="s1" id="mwBrM">'7'</span><span class="p" id="mwBrQ">);</span>
The equivalent of this before ES6, was creating a function that instantiates an object as such
<span id="mwBrg"></span><span class="kd" id="mwBrk">function</span><span class="w" id="mwBro"> </span><span class="nx" id="mwBrs">FooBar</span><span class="w" id="mwBrw"> </span><span class="p" id="mwBr0">(</span><span class="nx" id="mwBr4">baz</span><span class="p" id="mwBr8">)</span><span class="w" id="mwBsA"> </span><span class="p" id="mwBsE">{</span> <span class="w" id="mwBsI"> </span><span class="k" id="mwBsM">this</span><span class="p" id="mwBsQ">.</span><span class="nx" id="mwBsU">baz</span><span class="w" id="mwBsY"> </span><span class="o" id="mwBsc">=</span><span class="w" id="mwBsg"> </span><span class="nx" id="mwBsk">baz</span><span class="p" id="mwBso">;</span> <span class="p" id="mwBss">}</span>This is instantiated the same way as above.
The TypeScript equivalent of this would be:
<span id="mwBtE"></span><span class="kd" id="mwBtI">class</span><span class="w" id="mwBtM"> </span><span class="nx" id="mwBtQ">FooBar</span><span class="w" id="mwBtU"> </span><span class="p" id="mwBtY">{</span> <span class="w" id="mwBtc"> </span><span class="nx" id="mwBtg">baz</span><span class="o" id="mwBtk">:</span><span class="w" id="mwBto"> </span><span class="kt" id="mwBts">string</span><span class="p" id="mwBtw">;</span> <span class="w" id="mwBt0"> </span><span class="kr" id="mwBt4">constructor</span><span class="p" id="mwBt8">(</span><span class="nx" id="mwBuA">baz</span><span class="o" id="mwBuE">:</span><span class="w" id="mwBuI"> </span><span class="kt" id="mwBuM">string</span><span class="p" id="mwBuQ">)</span><span class="w" id="mwBuU"> </span><span class="p" id="mwBuY">{</span> <span class="w" id="mwBuc"> </span><span class="k" id="mwBug">this</span><span class="p" id="mwBuk">.</span><span class="nx" id="mwBuo">baz</span><span class="w" id="mwBus"> </span><span class="o" id="mwBuw">=</span><span class="w" id="mwBu0"> </span><span class="nx" id="mwBu4">baz</span><span class="p" id="mwBu8">;</span> <span class="w" id="mwBvA"> </span><span class="p" id="mwBvE">}</span> <span class="p" id="mwBvI">}</span> <span class="kd" id="mwBvM">const</span><span class="w" id="mwBvQ"> </span><span class="nx" id="mwBvU">foo</span><span class="o" id="mwBvY">:</span><span class="w" id="mwBvc"> </span><span class="kt" id="mwBvg">FooBar</span><span class="w" id="mwBvk"> </span><span class="o" id="mwBvo">=</span><span class="w" id="mwBvs"> </span><span class="ow" id="mwBvw">new</span><span class="w" id="mwBv0"> </span><span class="nx" id="mwBv4">FooBar</span><span class="p" id="mwBv8">(</span><span class="s1" id="mwBwA">'7'</span><span class="p" id="mwBwE">);</span>Object Pascal
In Object Pascal, the constructor is similar to a factory method. The only syntactic difference to regular methods is the keyword constructor in front of the name (instead of procedure or function). It can have any name, though the convention is to have Create as prefix, such as in CreateWithFormatting. Creating an instance of a class works like calling a static method of a class: TPerson.Create('Peter').
<span id="mwBw4"></span><span class="k" id="mwBw8">program</span><span class="w" id="mwBxA"> </span><span class="n" id="mwBxE">OopProgram</span><span class="o" id="mwBxI">;</span> <span class="k" id="mwBxM">type</span> <span class="w" id="mwBxQ"> </span><span class="n" id="mwBxU">TPerson</span><span class="w" id="mwBxY"> </span><span class="o" id="mwBxc">=</span><span class="w" id="mwBxg"> </span><span class="k" id="mwBxk">class</span> <span class="w" id="mwBxo"> </span><span class="kp" id="mwBxs">private</span> <span class="w" id="mwBxw"> </span><span class="n" id="mwBx0">FName</span><span class="o" id="mwBx4">:</span><span class="w" id="mwBx8"> </span><span class="k" id="mwByA">string</span><span class="o" id="mwByE">;</span> <span class="w" id="mwByI"> </span><span class="kp" id="mwByM">public</span> <span class="w" id="mwByQ"> </span><span class="k" id="mwByU">property</span><span class="w" id="mwByY"> </span><span class="py" id="mwByc">Name</span><span class="o" id="mwByg">:</span><span class="w" id="mwByk"> </span><span class="k" id="mwByo">string</span><span class="w" id="mwBys"> </span><span class="kp" id="mwByw">read</span><span class="w" id="mwBy0"> </span><span class="nf" id="mwBy4">FName</span><span class="o" id="mwBy8">;</span> <span class="w" id="mwBzA"> </span><span class="k" id="mwBzE">constructor</span><span class="w" id="mwBzI"> </span><span class="nf" id="mwBzM">Create</span><span class="p" id="mwBzQ">(</span><span class="n" id="mwBzU">AName</span><span class="o" id="mwBzY">:</span><span class="w" id="mwBzc"> </span><span class="k" id="mwBzg">string</span><span class="p" id="mwBzk">)</span><span class="o" id="mwBzo">;</span> <span class="w" id="mwBzs"> </span><span class="k" id="mwBzw">end</span><span class="o" id="mwBz0">;</span> <span class="k" id="mwBz4">constructor</span><span class="w" id="mwBz8"> </span><span class="nc" id="mwB0A">TPerson</span><span class="o" id="mwB0E">.</span><span class="nf" id="mwB0I">Create</span><span class="p" id="mwB0M">(</span><span class="n" id="mwB0Q">AName</span><span class="o" id="mwB0U">:</span><span class="w" id="mwB0Y"> </span><span class="k" id="mwB0c">string</span><span class="p" id="mwB0g">)</span><span class="o" id="mwB0k">;</span> <span class="k" id="mwB0o">begin</span> <span class="w" id="mwB0s"> </span><span class="n" id="mwB0w">FName</span><span class="w" id="mwB00"> </span><span class="o" id="mwB04">:=</span><span class="w" id="mwB08"> </span><span class="n" id="mwB1A">AName</span><span class="o" id="mwB1E">;</span> <span class="k" id="mwB1I">end</span><span class="o" id="mwB1M">;</span> <span class="k" id="mwB1Q">var</span> <span class="w" id="mwB1U"> </span><span class="n" id="mwB1Y">Person</span><span class="o" id="mwB1c">:</span><span class="w" id="mwB1g"> </span><span class="n" id="mwB1k">TPerson</span><span class="o" id="mwB1o">;</span> <span class="k" id="mwB1s">begin</span> <span class="w" id="mwB1w"> </span><span class="n" id="mwB10">Person</span><span class="w" id="mwB14"> </span><span class="o" id="mwB18">:=</span><span class="w" id="mwB2A"> </span><span class="n" id="mwB2E">TPerson</span><span class="o" id="mwB2I">.</span><span class="n" id="mwB2M">Create</span><span class="p" id="mwB2Q">(</span><span class="s" id="mwB2U">'Peter'</span><span class="p" id="mwB2Y">)</span><span class="o" id="mwB2c">;</span><span class="w" id="mwB2g"> </span><span class="c1" id="mwB2k">// allocates an instance of TPerson and then calls TPerson.Create with the parameter AName = 'Peter'</span> <span class="k" id="mwB2o">end</span><span class="o" id="mwB2s">.</span>
OCaml
In OCaml, there is one constructor. Parameters are defined right after the class name. They can be used to initialize instance variables and are accessible throughout the class. An anonymous hidden method called initializer allows to evaluate an expression immediately after the object has been built.
<span id="mwB3Y"></span><span class="k" id="mwB3c">class</span> <span class="n" id="mwB3g">person</span> <span class="n" id="mwB3k">first_name</span> <span class="n" id="mwB3o">last_name</span> <span class="o" id="mwB3s">=</span> <span class="k" id="mwB3w">object</span> <span class="k" id="mwB30">val</span> <span class="n" id="mwB34">full_name</span> <span class="o" id="mwB38">=</span> <span class="n" id="mwB4A">first_name</span> <span class="o" id="mwB4E">^</span> <span class="s2" id="mwB4I">" "</span> <span class="o" id="mwB4M">^</span> <span class="n" id="mwB4Q">last_name</span> <span class="k" id="mwB4U">initializer</span> <span class="n" id="mwB4Y">print_endline</span><span class="o" id="mwB4c">(</span><span class="s2" id="mwB4g">"Hello there, I am "</span> <span class="o" id="mwB4k">^</span> <span class="n" id="mwB4o">full_name</span> <span class="o" id="mwB4s">^</span> <span class="s2" id="mwB4w">"."</span><span class="o" id="mwB40">)</span> <span class="k" id="mwB44">method</span> <span class="n" id="mwB48">get_last_name</span> <span class="o" id="mwB5A">=</span> <span class="n" id="mwB5E">last_name</span> <span class="k" id="mwB5I">end</span><span class="o" id="mwB5M">;;</span> <span class="k" id="mwB5Q">let</span> <span class="n" id="mwB5U">alonzo</span> <span class="o" id="mwB5Y">=</span> <span class="k" id="mwB5c">new</span> <span class="n" id="mwB5g">person</span> <span class="s2" id="mwB5k">"Alonzo"</span> <span class="s2" id="mwB5o">"Church"</span> <span class="k" id="mwB5s">in</span> <span class="c" id="mwB5w">(*Hello there, I am Alonzo Church.*)</span> <span class="n" id="mwB50">print_endline</span> <span class="n" id="mwB54">alonzo</span><span class="o" id="mwB58">#</span><span class="n" id="mwB6A">get_last_name</span> <span class="c" id="mwB6E">(*Church*)</span>
PHP
In PHP version 5 and above, the constructor is a method named __construct() (notice that it's a double underscore), which the keyword new automatically calls after creating the object. It is usually used to automatically perform initializations such as property initializations. Constructors can also accept arguments, in which case, when the new statement is written, you also need to send the constructor arguments for the parameters.
<span id="mwB64"></span><span class="k" id="mwB68">class</span> <span class="nc" id="mwB7A">Person</span> <span class="p" id="mwB7E">{</span> <span class="k" id="mwB7I">private</span> <span class="nx" id="mwB7M">string</span> <span class="nv" id="mwB7Q">$name</span><span class="p" id="mwB7U">;</span> <span class="k" id="mwB7Y">public</span> <span class="k" id="mwB7c">function</span> <span class="fm" id="mwB7g">__construct</span><span class="p" id="mwB7k">(</span><span class="nx" id="mwB7o">string</span> <span class="nv" id="mwB7s">$name</span><span class="p" id="mwB7w">)</span><span class="o" id="mwB70">:</span> <span class="nx" id="mwB74">void</span> <span class="p" id="mwB78">{</span> <span class="nv" id="mwB8A">$this</span><span class="o" id="mwB8E">-></span><span class="na" id="mwB8I">name</span> <span class="o" id="mwB8M">=</span> <span class="nv" id="mwB8Q">$name</span><span class="p" id="mwB8U">;</span> <span class="p" id="mwB8Y">}</span> <span class="k" id="mwB8c">public</span> <span class="k" id="mwB8g">function</span> <span class="nf" id="mwB8k">getName</span><span class="p" id="mwB8o">()</span><span class="o" id="mwB8s">:</span> <span class="nx" id="mwB8w">string</span> <span class="p" id="mwB80">{</span> <span class="k" id="mwB84">return</span> <span class="nv" id="mwB88">$this</span><span class="o" id="mwB9A">-></span><span class="na" id="mwB9E">name</span><span class="p" id="mwB9I">;</span> <span class="p" id="mwB9M">}</span> <span class="p" id="mwB9Q">}</span>In PHP, a class is only allowed to declare a maximum of one constructor method. Static methods, factory classes or optional constructor arguments are some ways to facilitate multiple ways to create objects of a PHP class.
Perl 5
In Perl version 5, by default, constructors are factory methods, that is, methods that create and return the object, concretely meaning create and return a blessed reference. A typical object is a reference to a hash, though rarely references to other types are used too. By convention the only constructor is named new, though it is allowed to name it otherwise, or to have multiple constructors. For example, a Person class may have a constructor named new, and a constructor new_from_file which reads a file for Person attributes, and new_from_person which uses another Person object as a template.
<span id="mwB-A"></span><span class="k" id="mwB-E">package</span><span class="w" id="mwB-I"> </span><span class="nn" id="mwB-M">Person</span><span class="p" id="mwB-Q">;</span> <span class="c1" id="mwB-U"># In Perl constructors are named 'new' by convention.</span> <span class="k" id="mwB-Y">sub</span><span class="w" id="mwB-c"> </span><span class="nf" id="mwB-g">new</span><span class="w" id="mwB-k"> </span><span class="p" id="mwB-o">{</span> <span class="w" id="mwB-s"> </span><span class="c1" id="mwB-w"># Class name is implicitly passed in as 0th argument.</span> <span class="w" id="mwB-0"> </span><span class="k" id="mwB-4">my</span><span class="w" id="mwB-8"> </span><span class="nv" id="mwB_A">$class</span><span class="w" id="mwB_E"> </span><span class="o" id="mwB_I">=</span><span class="w" id="mwB_M"> </span><span class="nb" id="mwB_Q">shift</span><span class="p" id="mwB_U">;</span> <span class="w" id="mwB_Y"> </span><span class="c1" id="mwB_c"># Default attribute values, if you have any.</span> <span class="w" id="mwB_g"> </span><span class="k" id="mwB_k">my</span><span class="w" id="mwB_o"> </span><span class="nv" id="mwB_s">%defaults</span><span class="w" id="mwB_w"> </span><span class="o" id="mwB_0">=</span><span class="w" id="mwB_4"> </span><span class="p" id="mwB_8">(</span><span class="w" id="mwCAA"> </span><span class="n" id="mwCAE">foo</span><span class="w" id="mwCAI"> </span><span class="o" id="mwCAM">=></span><span class="w" id="mwCAQ"> </span><span class="s" id="mwCAU">"bar"</span><span class="w" id="mwCAY"> </span><span class="p" id="mwCAc">);</span> <span class="w" id="mwCAg"> </span><span class="c1" id="mwCAk"># Initialize attributes as a combination of default values and arguments passed.</span> <span class="w" id="mwCAo"> </span><span class="k" id="mwCAs">my</span><span class="w" id="mwCAw"> </span><span class="nv" id="mwCA0">$self</span><span class="w" id="mwCA4"> </span><span class="o" id="mwCA8">=</span><span class="w" id="mwCBA"> </span><span class="p" id="mwCBE">{</span><span class="w" id="mwCBI"> </span><span class="nv" id="mwCBM">%defaults</span><span class="p" id="mwCBQ">,</span><span class="w" id="mwCBU"> </span><span class="nv" id="mwCBY">@_</span><span class="w" id="mwCBc"> </span><span class="p" id="mwCBg">};</span> <span class="w" id="mwCBk"> </span><span class="c1" id="mwCBo"># Check for required arguments, class invariant, etc.</span> <span class="w" id="mwCBs"> </span><span class="k" id="mwCBw">if</span><span class="w" id="mwCB0"> </span><span class="p" id="mwCB4">(</span><span class="w" id="mwCB8"> </span><span class="ow" id="mwCCA">not</span><span class="w" id="mwCCE"> </span><span class="nb" id="mwCCI">defined</span><span class="w" id="mwCCM"> </span><span class="nv" id="mwCCQ">$self</span><span class="o" id="mwCCU">-></span><span class="p" id="mwCCY">{</span><span class="n" id="mwCCc">first_name</span><span class="p" id="mwCCg">}</span><span class="w" id="mwCCk"> </span><span class="p" id="mwCCo">)</span><span class="w" id="mwCCs"> </span><span class="p" id="mwCCw">{</span> <span class="w" id="mwCC0"> </span><span class="nb" id="mwCC4">die</span><span class="w" id="mwCC8"> </span><span class="s" id="mwCDA">"Mandatory attribute missing in Person->new(): first_name"</span><span class="p" id="mwCDE">;</span> <span class="w" id="mwCDI"> </span><span class="p" id="mwCDM">}</span> <span class="w" id="mwCDQ"> </span><span class="k" id="mwCDU">if</span><span class="w" id="mwCDY"> </span><span class="p" id="mwCDc">(</span><span class="w" id="mwCDg"> </span><span class="ow" id="mwCDk">not</span><span class="w" id="mwCDo"> </span><span class="nb" id="mwCDs">defined</span><span class="w" id="mwCDw"> </span><span class="nv" id="mwCD0">$self</span><span class="o" id="mwCD4">-></span><span class="p" id="mwCD8">{</span><span class="n" id="mwCEA">last_name</span><span class="p" id="mwCEE">}</span><span class="w" id="mwCEI"> </span><span class="p" id="mwCEM">)</span><span class="w" id="mwCEQ"> </span><span class="p" id="mwCEU">{</span> <span class="w" id="mwCEY"> </span><span class="nb" id="mwCEc">die</span><span class="w" id="mwCEg"> </span><span class="s" id="mwCEk">"Mandatory attribute missing in Person->new(): last_name"</span><span class="p" id="mwCEo">;</span> <span class="w" id="mwCEs"> </span><span class="p" id="mwCEw">}</span> <span class="w" id="mwCE0"> </span><span class="k" id="mwCE4">if</span><span class="w" id="mwCE8"> </span><span class="p" id="mwCFA">(</span><span class="w" id="mwCFE"> </span><span class="nb" id="mwCFI">defined</span><span class="w" id="mwCFM"> </span><span class="nv" id="mwCFQ">$self</span><span class="o" id="mwCFU">-></span><span class="p" id="mwCFY">{</span><span class="n" id="mwCFc">age</span><span class="p" id="mwCFg">}</span><span class="w" id="mwCFk"> </span><span class="ow" id="mwCFo">and</span><span class="w" id="mwCFs"> </span><span class="nv" id="mwCFw">$self</span><span class="o" id="mwCF0">-></span><span class="p" id="mwCF4">{</span><span class="n" id="mwCF8">age</span><span class="p" id="mwCGA">}</span><span class="w" id="mwCGE"> </span><span class="o" id="mwCGI"><</span><span class="w" id="mwCGM"> </span><span class="mi" id="mwCGQ">18</span><span class="w" id="mwCGU"> </span><span class="p" id="mwCGY">)</span><span class="w" id="mwCGc"> </span><span class="p" id="mwCGg">{</span> <span class="w" id="mwCGk"> </span><span class="nb" id="mwCGo">die</span><span class="w" id="mwCGs"> </span><span class="s" id="mwCGw">"Invalid attribute value in Person->new(): age < 18"</span><span class="p" id="mwCG0">;</span> <span class="w" id="mwCG4"> </span><span class="p" id="mwCG8">}</span> <span class="w" id="mwCHA"> </span><span class="c1" id="mwCHE"># Perl makes an object belong to a class by 'bless'.</span> <span class="w" id="mwCHI"> </span><span class="nb" id="mwCHM">bless</span><span class="w" id="mwCHQ"> </span><span class="nv" id="mwCHU">$self</span><span class="p" id="mwCHY">,</span><span class="w" id="mwCHc"> </span><span class="nv" id="mwCHg">$class</span><span class="p" id="mwCHk">;</span> <span class="w" id="mwCHo"> </span><span class="k" id="mwCHs">return</span><span class="w" id="mwCHw"> </span><span class="nv" id="mwCH0">$self</span><span class="p" id="mwCH4">;</span> <span class="p" id="mwCH8">}</span> <span class="mi" id="mwCIA">1</span><span class="p" id="mwCIE">;</span>Perl 5 with Moose
In the Moose object system for Perl, most of this boilerplate can be omitted, a default new is created, attributes can be specified, and whether they can be set, reset, or are required. In addition, any extra constructor functionality can be included in a BUILD method which the Moose generated constructor will call, after it has checked the arguments. A BUILDARGS method can be specified to handle constructor arguments not in hashref / key => value form.
<span id="mwCIo"></span><span class="k" id="mwCIs">package</span><span class="w" id="mwCIw"> </span><span class="nn" id="mwCI0">Person</span><span class="p" id="mwCI4">;</span> <span class="c1" id="mwCI8"># enable Moose-style object construction</span> <span class="k" id="mwCJA">use</span><span class="w" id="mwCJE"> </span><span class="nn" id="mwCJI">Moose</span><span class="p" id="mwCJM">;</span> <span class="c1" id="mwCJQ"># first name ( a string) can only be set at construction time ('ro')</span> <span class="n" id="mwCJU">has</span><span class="w" id="mwCJY"> </span><span class="n" id="mwCJc">first_name</span><span class="w" id="mwCJg"> </span><span class="o" id="mwCJk">=></span><span class="w" id="mwCJo"> </span><span class="p" id="mwCJs">(</span><span class="n" id="mwCJw">is</span><span class="w" id="mwCJ0"> </span><span class="o" id="mwCJ4">=></span><span class="w" id="mwCJ8"> </span><span class="s" id="mwCKA">'ro'</span><span class="p" id="mwCKE">,</span><span class="w" id="mwCKI"> </span><span class="n" id="mwCKM">isa</span><span class="w" id="mwCKQ"> </span><span class="o" id="mwCKU">=></span><span class="w" id="mwCKY"> </span><span class="s" id="mwCKc">'Str'</span><span class="p" id="mwCKg">,</span><span class="w" id="mwCKk"> </span><span class="n" id="mwCKo">required</span><span class="w" id="mwCKs"> </span><span class="o" id="mwCKw">=></span><span class="w" id="mwCK0"> </span><span class="mi" id="mwCK4">1</span><span class="p" id="mwCK8">);</span> <span class="c1" id="mwCLA"># last name ( a string) can only be set at construction time ('ro')</span> <span class="n" id="mwCLE">has</span><span class="w" id="mwCLI"> </span><span class="n" id="mwCLM">last_name</span><span class="w" id="mwCLQ"> </span><span class="o" id="mwCLU">=></span><span class="w" id="mwCLY"> </span><span class="p" id="mwCLc">(</span><span class="n" id="mwCLg">is</span><span class="w" id="mwCLk"> </span><span class="o" id="mwCLo">=></span><span class="w" id="mwCLs"> </span><span class="s" id="mwCLw">'ro'</span><span class="p" id="mwCL0">,</span><span class="w" id="mwCL4"> </span><span class="n" id="mwCL8">isa</span><span class="w" id="mwCMA"> </span><span class="o" id="mwCME">=></span><span class="w" id="mwCMI"> </span><span class="s" id="mwCMM">'Str'</span><span class="p" id="mwCMQ">,</span><span class="w" id="mwCMU"> </span><span class="n" id="mwCMY">required</span><span class="w" id="mwCMc"> </span><span class="o" id="mwCMg">=></span><span class="w" id="mwCMk"> </span><span class="mi" id="mwCMo">1</span><span class="p" id="mwCMs">);</span> <span class="c1" id="mwCMw"># age (Integer) can be modified after construction ('rw'), and is not required</span> <span class="c1" id="mwCM0"># to be passed to be constructor. Also creates a 'has_age' method which returns</span> <span class="c1" id="mwCM4"># true if age has been set</span> <span class="n" id="mwCM8">has</span><span class="w" id="mwCNA"> </span><span class="n" id="mwCNE">age</span><span class="w" id="mwCNI"> </span><span class="o" id="mwCNM">=></span><span class="w" id="mwCNQ"> </span><span class="p" id="mwCNU">(</span><span class="n" id="mwCNY">is</span><span class="w" id="mwCNc"> </span><span class="o" id="mwCNg">=></span><span class="w" id="mwCNk"> </span><span class="s" id="mwCNo">'rw'</span><span class="p" id="mwCNs">,</span><span class="w" id="mwCNw"> </span><span class="n" id="mwCN0">isa</span><span class="w" id="mwCN4"> </span><span class="o" id="mwCN8">=></span><span class="w" id="mwCOA"> </span><span class="s" id="mwCOE">'Int'</span><span class="p" id="mwCOI">,</span><span class="w" id="mwCOM"> </span><span class="n" id="mwCOQ">predicate</span><span class="w" id="mwCOU"> </span><span class="o" id="mwCOY">=></span><span class="w" id="mwCOc"> </span><span class="s" id="mwCOg">'has_age'</span><span class="p" id="mwCOk">);</span> <span class="c1" id="mwCOo"># Check custom requirements</span> <span class="k" id="mwCOs">sub</span><span class="w" id="mwCOw"> </span><span class="nf" id="mwCO0">BUILD</span><span class="w" id="mwCO4"> </span><span class="p" id="mwCO8">{</span> <span class="w" id="mwCPA"> </span><span class="k" id="mwCPE">my</span><span class="w" id="mwCPI"> </span><span class="nv" id="mwCPM">$self</span><span class="w" id="mwCPQ"> </span><span class="o" id="mwCPU">=</span><span class="w" id="mwCPY"> </span><span class="nb" id="mwCPc">shift</span><span class="p" id="mwCPg">;</span> <span class="w" id="mwCPk"> </span><span class="k" id="mwCPo">if</span><span class="w" id="mwCPs"> </span><span class="p" id="mwCPw">(</span><span class="nv" id="mwCP0">$self</span><span class="o" id="mwCP4">-></span><span class="n" id="mwCP8">has_age</span><span class="w" id="mwCQA"> </span><span class="o" id="mwCQE">&&</span><span class="w" id="mwCQI"> </span><span class="nv" id="mwCQM">$self</span><span class="o" id="mwCQQ">-></span><span class="n" id="mwCQU">age</span><span class="w" id="mwCQY"> </span><span class="o" id="mwCQc"><</span><span class="w" id="mwCQg"> </span><span class="mi" id="mwCQk">18</span><span class="p" id="mwCQo">)</span><span class="w" id="mwCQs"> </span><span class="p" id="mwCQw">{</span><span class="w" id="mwCQ0"> </span><span class="c1" id="mwCQ4"># no under 18s</span> <span class="w" id="mwCQ8"> </span><span class="nb" id="mwCRA">die</span><span class="w" id="mwCRE"> </span><span class="s" id="mwCRI">"No under-18 Persons"</span><span class="p" id="mwCRM">;</span> <span class="w" id="mwCRQ"> </span><span class="p" id="mwCRU">}</span> <span class="p" id="mwCRY">}</span> <span class="mi" id="mwCRc">1</span><span class="p" id="mwCRg">;</span>In both cases the Person class is instiated like this:
<span id="mwCRw"></span><span class="k" id="mwCR0">use</span><span class="w" id="mwCR4"> </span><span class="nn" id="mwCR8">Person</span><span class="p" id="mwCSA">;</span> <span class="k" id="mwCSE">my</span><span class="w" id="mwCSI"> </span><span class="nv" id="mwCSM">$p</span><span class="w" id="mwCSQ"> </span><span class="o" id="mwCSU">=</span><span class="w" id="mwCSY"> </span><span class="nn" id="mwCSc">Person</span><span class="o" id="mwCSg">-></span><span class="k" id="mwCSk">new</span><span class="p" id="mwCSo">(</span><span class="w" id="mwCSs"> </span><span class="n" id="mwCSw">first_name</span><span class="w" id="mwCS0"> </span><span class="o" id="mwCS4">=></span><span class="w" id="mwCS8"> </span><span class="s" id="mwCTA">'Sam'</span><span class="p" id="mwCTE">,</span><span class="w" id="mwCTI"> </span><span class="n" id="mwCTM">last_name</span><span class="w" id="mwCTQ"> </span><span class="o" id="mwCTU">=></span><span class="w" id="mwCTY"> </span><span class="s" id="mwCTc">'Ashe'</span><span class="p" id="mwCTg">,</span><span class="w" id="mwCTk"> </span><span class="n" id="mwCTo">age</span><span class="w" id="mwCTs"> </span><span class="o" id="mwCTw">=></span><span class="w" id="mwCT0"> </span><span class="mi" id="mwCT4">42</span><span class="w" id="mwCT8"> </span><span class="p" id="mwCUA">);</span>
Python
In Python, constructors are defined by one or both of __new__ and __init__ methods. A new instance is created by calling the class as if it were a function, which calls the __new__ and __init__ methods. If a constructor method is not defined in the class, the next one found in the class's Method Resolution Order will be called.
In the typical case, only the __init__ method need be defined. (The most common exception is for immutable objects.)
<span id="mwCVA"></span><span class="k" id="mwCVE">class</span><span class="w" id="mwCVI"> </span><span class="nc" id="mwCVM">ExampleClass</span><span class="p" id="mwCVQ">:</span> <span class="k" id="mwCVU">def</span><span class="w" id="mwCVY"> </span><span class="fm" id="mwCVc">__new__</span><span class="p" id="mwCVg">(</span><span class="bp" id="mwCVk">cls</span><span class="p" id="mwCVo">:</span> <span class="nb" id="mwCVs">type</span><span class="p" id="mwCVw">,</span> <span class="n" id="mwCV0">value</span><span class="p" id="mwCV4">:</span> <span class="nb" id="mwCV8">int</span><span class="p" id="mwCWA">)</span> <span class="o" id="mwCWE">-></span> <span class="s1" id="mwCWI">'ExampleClass'</span><span class="p" id="mwCWM">:</span> <span class="nb" id="mwCWQ">print</span><span class="p" id="mwCWU">(</span><span class="s2" id="mwCWY">"Creating new instance..."</span><span class="p" id="mwCWc">)</span> <span class="c1" id="mwCWg"># Call the superclass constructor to create the instance.</span> <span class="n" id="mwCWk">instance</span><span class="p" id="mwCWo">:</span> <span class="s1" id="mwCWs">'ExampleClass'</span> <span class="o" id="mwCWw">=</span> <span class="nb" id="mwCW0">super</span><span class="p" id="mwCW4">(</span><span class="n" id="mwCW8">ExampleClass</span><span class="p" id="mwCXA">,</span> <span class="bp" id="mwCXE">cls</span><span class="p" id="mwCXI">)</span><span class="o" id="mwCXM">.</span><span class="fm" id="mwCXQ">__new__</span><span class="p" id="mwCXU">(</span><span class="bp" id="mwCXY">cls</span><span class="p" id="mwCXc">)</span> <span class="k" id="mwCXg">return</span> <span class="n" id="mwCXk">instance</span> <span class="k" id="mwCXo">def</span><span class="w" id="mwCXs"> </span><span class="fm" id="mwCXw">__init__</span><span class="p" id="mwCX0">(</span><span class="bp" id="mwCX4">self</span><span class="p" id="mwCX8">,</span> <span class="n" id="mwCYA">value</span><span class="p" id="mwCYE">:</span> <span class="nb" id="mwCYI">int</span><span class="p" id="mwCYM">)</span> <span class="o" id="mwCYQ">-></span> <span class="kc" id="mwCYU">None</span><span class="p" id="mwCYY">:</span> <span class="nb" id="mwCYc">print</span><span class="p" id="mwCYg">(</span><span class="s2" id="mwCYk">"Initialising instance..."</span><span class="p" id="mwCYo">)</span> <span class="bp" id="mwCYs">self</span><span class="o" id="mwCYw">.</span><span class="n" id="mwCY0">payload</span><span class="p" id="mwCY4">:</span> <span class="nb" id="mwCY8">int</span> <span class="o" id="mwCZA">=</span> <span class="n" id="mwCZE">value</span> <span class="k" id="mwCZI">if</span> <span class="vm" id="mwCZM">__name__</span> <span class="o" id="mwCZQ">==</span> <span class="s2" id="mwCZU">"__main__"</span><span class="p" id="mwCZY">:</span> <span class="n" id="mwCZc">exampleInstance</span><span class="p" id="mwCZg">:</span> <span class="n" id="mwCZk">ExampleClass</span> <span class="o" id="mwCZo">=</span> <span class="n" id="mwCZs">ExampleClass</span><span class="p" id="mwCZw">(</span><span class="mi" id="mwCZ0">42</span><span class="p" id="mwCZ4">)</span> <span class="nb" id="mwCZ8">print</span><span class="p" id="mwCaA">(</span><span class="n" id="mwCaE">exampleInstance</span><span class="o" id="mwCaI">.</span><span class="n" id="mwCaM">payload</span><span class="p" id="mwCaQ">)</span>
This prints:
Creating new instance... Initialising instance... 42
Classes normally act as factories for new instances of themselves, that is, a class is a callable object (like a function), with the call being the constructor, and calling the class returns an instance of that class. However the __new__ method is permitted to return something other than an instance of the class for specialised purposes. In that case, the __init__ is not invoked.
Raku
In Raku, even more boilerplate can be omitted, given that a default new method is inherited, attributes can be specified, and whether they can be set, reset, or are required. In addition, any extra constructor functionality can be included in a BUILD method which will get called to allow for custom initialization. A TWEAK method can be specified to post-process any attributes already (implicitly) initialized.
<span id="mwCbc"></span><span class="k" id="mwCbg">class</span> <span class="n" id="mwCbk">Person</span> { <span class="k" id="mwCbo">has</span> <span class="nb" id="mwCbs">Str</span> <span class="nv" id="mwCbw">$.first-name</span> <span class="k" id="mwCb0">is</span> <span class="k" id="mwCb4">required</span>; <span class="c1" id="mwCb8"># First name (a string) can only be set at</span> <span class="c1" id="mwCcA"># construction time (the . means "public").</span> <span class="k" id="mwCcE">has</span> <span class="nb" id="mwCcI">Str</span> <span class="nv" id="mwCcM">$.last-name</span> <span class="k" id="mwCcQ">is</span> <span class="k" id="mwCcU">required</span>; <span class="c1" id="mwCcY"># Last name (a string) can only be set at</span> <span class="c1" id="mwCcc"># construction time (a ! would mean "private").</span> <span class="k" id="mwCcg">has</span> <span class="nb" id="mwCck">Int</span> <span class="nv" id="mwCco">$.age</span> <span class="k" id="mwCcs">is</span> <span class="k" id="mwCcw">rw</span>; <span class="c1" id="mwCc0"># Age (an integer) can be modified after </span> <span class="c1" id="mwCc4"># construction ('rw'), and is not required</span> <span class="c1" id="mwCc8"># during the object instantiation.</span> <span class="c1" id="mwCdA"># Create a 'full-name' method which returns the person's full name.</span> <span class="c1" id="mwCdE"># This method can be accessed outside the class.</span> <span class="k" id="mwCdI">method</span> <span class="n" id="mwCdM">full-name</span> { <span class="nv" id="mwCdQ">$!first-name</span>.<span class="nb" id="mwCdU">tc</span> ~ <span class="s" id="mwCdY">" "</span> ~ <span class="nv" id="mwCdc">$!last-name</span>.<span class="nb" id="mwCdg">tc</span> } <span class="c1" id="mwCdk"># Create a 'has-age' method which returns true if age has been set.</span> <span class="c1" id="mwCdo"># This method is used only inside the class so it's declared as "private"</span> <span class="c1" id="mwCds"># by prepending its name with a !</span> <span class="k" id="mwCdw">method</span> !<span class="n" id="mwCd0">has-age</span> { <span class="nb" id="mwCd4">self</span>.<span class="n" id="mwCd8">age</span>.<span class="nb" id="mwCeA">defined</span> } <span class="c1" id="mwCeE"># Check custom requirements</span> <span class="k" id="mwCeI">method</span> <span class="n" id="mwCeM">TWEAK</span> { <span class="k" id="mwCeQ">if</span> <span class="nb" id="mwCeU">self</span><span class="o" id="mwCeY">!</span><span class="n" id="mwCec">has-age</span> && <span class="nv" id="mwCeg">$!age</span> < <span class="mi" id="mwCek">18</span> { <span class="c1" id="mwCeo"># No under 18</span> <span class="nb" id="mwCes">die</span> <span class="s" id="mwCew">"No person under 18"</span>; } } }The Person class is instantiated like this:
<span id="mwCfA"></span><span class="k" id="mwCfE">my</span> <span class="nv" id="mwCfI">$p0</span> = <span class="n" id="mwCfM">Person</span>.<span class="nb" id="mwCfQ">new</span>( <span class="n" id="mwCfU">first-name</span> => <span class="s" id="mwCfY">'Sam'</span>, <span class="n" id="mwCfc">last-name</span> => <span class="s" id="mwCfg">'Ashe'</span>, <span class="n" id="mwCfk">age</span> => <span class="mi" id="mwCfo">42</span> ); <span class="k" id="mwCfs">my</span> <span class="nv" id="mwCfw">$p1</span> = <span class="n" id="mwCf0">Person</span>.<span class="nb" id="mwCf4">new</span>( <span class="n" id="mwCf8">first-name</span> => <span class="s" id="mwCgA">'grace'</span>, <span class="n" id="mwCgE">last-name</span> => <span class="s" id="mwCgI">'hopper'</span> ); <span class="nb" id="mwCgM">say</span> <span class="nv" id="mwCgQ">$p1</span>.<span class="n" id="mwCgU">full-name</span>(); <span class="c1" id="mwCgY"># OUTPUT: «Grace Hopper»</span>
Alternatively, the named parameters can be specified using the colon-pair syntax in Perl 6:
<span id="mwCgs"></span><span class="k" id="mwCgw">my</span> <span class="nv" id="mwCg0">$p0</span> = <span class="n" id="mwCg4">Person</span>.<span class="nb" id="mwCg8">new</span>( :<span class="n" id="mwChA">first-name</span><span class="s" id="mwChE"><Sam></span>, :<span class="n" id="mwChI">last-name</span><span class="s" id="mwChM"><Ashe></span>, :<span class="n" id="mwChQ">age</span>(<span class="mi" id="mwChU">42</span>) ); <span class="k" id="mwChY">my</span> <span class="nv" id="mwChc">$p1</span> = <span class="n" id="mwChg">Person</span>.<span class="nb" id="mwChk">new</span>( :<span class="n" id="mwCho">first-name</span><span class="s" id="mwChs"><Grace></span>, :<span class="n" id="mwChw">last-name</span><span class="s" id="mwCh0"><Hopper></span> );
And should you have set up variables with names identical to the named parameters, you can use a shortcut that will use the name of the variable for the named parameter:
<span id="mwCiI"></span><span class="k" id="mwCiM">my</span> <span class="nv" id="mwCiQ">$first-name</span> = <span class="s" id="mwCiU">"Sam"</span>; <span class="k" id="mwCiY">my</span> <span class="nv" id="mwCic">$last-name</span> = <span class="s" id="mwCig">"Ashe"</span>; <span class="k" id="mwCik">my</span> <span class="nv" id="mwCio">$age</span> = <span class="mi" id="mwCis">42</span>; <span class="k" id="mwCiw">my</span> <span class="nv" id="mwCi0">$p0</span> = <span class="n" id="mwCi4">Person</span>.<span class="nb" id="mwCi8">new</span>( :<span class="nv" id="mwCjA">$first-name</span>, :<span class="nv" id="mwCjE">$last-name</span>, :<span class="nv" id="mwCjI">$age</span> );
Ruby
In Ruby, constructors are created by defining a method called initialize. This method is executed to initialize each new instance.
<span id="mwCjk"></span><span class="gp" id="mwCjo">irb(main):001:0> </span><span class="k" id="mwCjs">class</span><span class="w" id="mwCjw"> </span><span class="nc" id="mwCj0">ExampleClass</span> <span class="gp" id="mwCj4">irb(main):002:1> </span><span class="w" id="mwCj8"> </span><span class="k" id="mwCkA">def</span><span class="w" id="mwCkE"> </span><span class="nf" id="mwCkI">initialize</span> <span class="gp" id="mwCkM">irb(main):003:2> </span><span class="w" id="mwCkQ"> </span><span class="nb" id="mwCkU">puts</span><span class="w" id="mwCkY"> </span><span class="s2" id="mwCkc">"Hello there"</span> <span class="gp" id="mwCkg">irb(main):004:2> </span><span class="w" id="mwCkk"> </span><span class="k" id="mwCko">end</span> <span class="gp" id="mwCks">irb(main):005:1> </span><span class="k" id="mwCkw">end</span> <span class="go" id="mwCk0">=> nil</span> <span class="gp" id="mwCk4">irb(main):006:0> </span><span class="no" id="mwCk8">ExampleClass</span><span class="o" id="mwClA">.</span><span class="n" id="mwClE">new</span> <span class="go" id="mwClI">Hello there</span> <span class="go" id="mwClM">=> #<ExampleClass:0x007fb3f4299118></span>
Rust
Rust does not have constructors in the sense of object-oriented programming, but often structs have a new() method that essentially acts as a constructor. The return type is usually indicated as Self.
<span id="mwCls"></span><span class="k" id="mwClw">struct</span><span class="w" id="mwCl0"> </span><span class="nc" id="mwCl4">Point</span><span class="w" id="mwCl8"> </span><span class="p" id="mwCmA">{</span> <span class="w" id="mwCmE"> </span><span class="n" id="mwCmI">x</span><span class="p" id="mwCmM">:</span><span class="w" id="mwCmQ"> </span><span class="kt" id="mwCmU">i32</span><span class="p" id="mwCmY">,</span> <span class="w" id="mwCmc"> </span><span class="n" id="mwCmg">y</span><span class="p" id="mwCmk">:</span><span class="w" id="mwCmo"> </span><span class="kt" id="mwCms">i32</span><span class="p" id="mwCmw">,</span> <span class="p" id="mwCm0">}</span> <span class="k" id="mwCm4">impl</span><span class="w" id="mwCm8"> </span><span class="n" id="mwCnA">Point</span><span class="w" id="mwCnE"> </span><span class="p" id="mwCnI">{</span> <span class="w" id="mwCnM"> </span><span class="k" id="mwCnQ">pub</span><span class="w" id="mwCnU"> </span><span class="k" id="mwCnY">fn</span><span class="w" id="mwCnc"> </span><span class="nf" id="mwCng">new</span><span class="p" id="mwCnk">(</span><span class="n" id="mwCno">x</span><span class="p" id="mwCns">:</span><span class="w" id="mwCnw"> </span><span class="kt" id="mwCn0">i32</span><span class="p" id="mwCn4">,</span><span class="w" id="mwCn8"> </span><span class="n" id="mwCoA">y</span><span class="p" id="mwCoE">:</span><span class="w" id="mwCoI"> </span><span class="kt" id="mwCoM">i32</span><span class="p" id="mwCoQ">)</span><span class="w" id="mwCoU"> </span><span class="p" id="mwCoY">-></span><span class="w" id="mwCoc"> </span><span class="nc" id="mwCog">Self</span><span class="w" id="mwCok"> </span><span class="p" id="mwCoo">{</span> <span class="w" id="mwCos"> </span><span class="n" id="mwCow">Point</span><span class="w" id="mwCo0"> </span><span class="p" id="mwCo4">{</span><span class="w" id="mwCo8"> </span><span class="n" id="mwCpA">x</span><span class="p" id="mwCpE">,</span><span class="w" id="mwCpI"> </span><span class="n" id="mwCpM">y</span><span class="w" id="mwCpQ"> </span><span class="p" id="mwCpU">}</span> <span class="w" id="mwCpY"> </span><span class="p" id="mwCpc">}</span> <span class="p" id="mwCpg">}</span> <span class="k" id="mwCpk">fn</span><span class="w" id="mwCpo"> </span><span class="nf" id="mwCps">main</span><span class="p" id="mwCpw">()</span><span class="w" id="mwCp0"> </span><span class="p" id="mwCp4">{</span> <span class="w" id="mwCp8"> </span><span class="kd" id="mwCqA">let</span><span class="w" id="mwCqE"> </span><span class="n" id="mwCqI">p</span><span class="p" id="mwCqM">:</span><span class="w" id="mwCqQ"> </span><span class="nc" id="mwCqU">Point</span><span class="w" id="mwCqY"> </span><span class="o" id="mwCqc">=</span><span class="w" id="mwCqg"> </span><span class="n" id="mwCqk">Point</span><span class="p" id="mwCqo">::</span><span class="n" id="mwCqs">new</span><span class="p" id="mwCqw">(</span><span class="mi" id="mwCq0">10</span><span class="p" id="mwCq4">,</span><span class="w" id="mwCq8"> </span><span class="mi" id="mwCrA">20</span><span class="p" id="mwCrE">);</span> <span class="w" id="mwCrI"> </span><span class="fm" id="mwCrM">println!</span><span class="p" id="mwCrQ">(</span><span class="s" id="mwCrU">"Point is at ({}, {})"</span><span class="p" id="mwCrY">,</span><span class="w" id="mwCrc"> </span><span class="n" id="mwCrg">p</span><span class="p" id="mwCrk">.</span><span class="n" id="mwCro">x</span><span class="p" id="mwCrs">,</span><span class="w" id="mwCrw"> </span><span class="n" id="mwCr0">p</span><span class="p" id="mwCr4">.</span><span class="n" id="mwCr8">y</span><span class="p" id="mwCsA">);</span> <span class="p" id="mwCsE">}</span>Visual Basic .NET
In Visual Basic .NET, constructors use a method declaration with the name "New".
<span id="mwCsg"></span><span class="k" id="mwCsk">Class</span><span class="w" id="mwCso"> </span><span class="nc" id="mwCss">Foobar</span> <span class="w" id="mwCsw"> </span><span class="k" id="mwCs0">Private</span><span class="w" id="mwCs4"> </span><span class="n" id="mwCs8">strData</span><span class="w" id="mwCtA"> </span><span class="ow" id="mwCtE">As</span><span class="w" id="mwCtI"> </span><span class="kt" id="mwCtM">String</span> <span class="w" id="mwCtQ"> </span><span class="c" id="mwCtU">' Constructor</span> <span class="w" id="mwCtY"> </span><span class="k" id="mwCtc">Public</span><span class="w" id="mwCtg"> </span><span class="k" id="mwCtk">Sub</span><span class="w" id="mwCto"> </span><span class="nf" id="mwCts">New</span><span class="p" id="mwCtw">(</span><span class="k" id="mwCt0">ByVal</span><span class="w" id="mwCt4"> </span><span class="n" id="mwCt8">someParam</span><span class="w" id="mwCuA"> </span><span class="ow" id="mwCuE">As</span><span class="w" id="mwCuI"> </span><span class="kt" id="mwCuM">String</span><span class="p" id="mwCuQ">)</span> <span class="w" id="mwCuU"> </span><span class="n" id="mwCuY">strData</span><span class="w" id="mwCuc"> </span><span class="o" id="mwCug">=</span><span class="w" id="mwCuk"> </span><span class="n" id="mwCuo">someParam</span> <span class="w" id="mwCus"> </span><span class="k" id="mwCuw">End</span><span class="w" id="mwCu0"> </span><span class="k" id="mwCu4">Sub</span> <span class="k" id="mwCu8">End</span><span class="w" id="mwCvA"> </span><span class="k" id="mwCvE">Class</span>
<span id="mwCvQ"></span><span class="c" id="mwCvU">' code somewhere else</span> <span class="c" id="mwCvY">' instantiating an object with the above constructor</span> <span class="k" id="mwCvc">Dim</span><span class="w" id="mwCvg"> </span><span class="n" id="mwCvk">foo</span><span class="w" id="mwCvo"> </span><span class="ow" id="mwCvs">As</span><span class="w" id="mwCvw"> </span><span class="k" id="mwCv0">New</span><span class="w" id="mwCv4"> </span><span class="n" id="mwCv8">Foobar</span><span class="p" id="mwCwA">(</span><span class="s" id="mwCwE">".NET"</span><span class="p" id="mwCwI">)</span>