构造器

在类别基础的面向对象程序设计中，构造器（英语： Constructor，有时简称ctor），别称：构造方法、构造函数、建构子）是一个类里用于创建对象的特殊子程序。它能初始化一个新建的对象，并时常会接受参数用以设定实例变量。
构造器跟一般的实例方法十分相似；但是与其它方法不同，构造器没有返回类型，不会被继承，且不会有范围修饰符。构造器的函数名称一般与它所属的类的名称相同。 它承担着初始化对象数据成员并创建类不变象的任务；在类不变象无效的时候它会失败。一个正确编写的构造器会使它生成的对象保持在一个有效状态。不可变对象必须在构造器内完成所有初始化。
多数编程语言允许构造器重载 - 一个类被允许拥有多个接受不同参数种类的构造器同时存在。一些编程语言允许某些特殊种类的构造器。使用单个类来具体地创建和返回新实例的构造器，时常被抽象为工厂方法 - 一种同样用来创建新对象，但会同时使用多个类，或者一些诸如对象池的分配方案来完成这一过程的子程序。

参数化构造器

接收参数的构造器被称为参数化构造器。参数的数量可以大于或等于一。例如，在C++中：
class Example{
     int x, y;
   public:
     Example();
     Example(int a, int b); // Parameterized constructor};Example :: Example(){}Example :: Example(int a, int b){
     x = a;
     y = b;}
使用参数化构造器声明对象时，必须传入初始值作为构造器的参数。在这种情况下，一般的声明对象的方法可能不再适用。
构造器函数的调用方式可以分为显式和隐式两种。
    Example e = Example(0, 50); // Explicit call

    Example e(0, 50);           // Implicit call

缺省构造器

如果在编写一个可实例化的类时没有专门编写构造器，多数编程语言会自动生成缺省构造器。
缺省构造器的特性依不同语言而定。某些情况下它会将所有的实例变量同时初始化到0，或者任何其他别的值；某些缺省构造器什么也不会做。

某些语言(Java, C#, VB .NET) 会缺省构造由该类类型定义的数组，使其充满空值引用。没有空值引用的语言一般会禁止缺省构造包含不可缺省构造对象的数组，或者要求在创建时专门初始化这些数值 (C++):
#include <iostream>class student{
             public:
                   int a,b;
                  student(a=0,b=0)   //default constructor};int main() {

}

转换构造器

转换构造器可定义从用户定义或内置类型转换成用户定义类型的作业。

复制构造器

复制构造器（英语：Copy constructor）是C++编程语言中的一种特别的构造器，习惯上用来创建一个全新的对象，这个全新的对象相当于已存在对象的副本。这个构造器只有一个参数（引数）：就是用来复制对象的引用（常用const修饰）。构造器也可以有更多的参数，但除了最左第一个参数是该类别的引用类别型外，其它参数必须有默认值。

移动构造器

移动构造函数（英语：Move constructor）是 C++11 中新增的一种构造函数，用来避免多余的分配新内存——复制——销毁旧内存的操作。参见 C++11 条目内的介绍。

内存机制

在 Java, C# 和 VB .NET 里，构造器会在一种叫做堆的特殊数据结构里创建作为引用类型的实例。值类型（例如 int, double 等等）则会创建在叫做栈的有序数据结构里。VB .NET and C# 会允许用 new 来创建值类型的实例。然而在这些语言里，即使使用这种方法创建的对象依然只会在栈里。
在 C++ 里，不用 new 创建的对象会保存在栈里，使用 new 创建时则会在堆里。它们必须分别使用析构函数或者 delete 操作才能被删除。

Visual Basic .NET

在Visual Basic .NET中, 构造器以"New"为定义方法，并且必须是个Sub。
Class Foobar
    Private strData As String

    ' Constructor
    Public Sub New(ByVal someParam As String)
        strData = someParam
    End SubEnd Class
' code somewhere else' instantiating an object with the above constructorDim foo As New Foobar(".NET")

C#

public class MyClass{
    private int a;
    private string b;

    // Constructor
    public MyClass() : this(42, "string")
    {
    }

    // Overloading a constructor
    public MyClass(int a, string b)
    {
        this.a = a;
        this.b = b;
    }}
// Code somewhere// Instantiating an object with the constructor aboveMyClass c = new MyClass(42, "string");

C# 静态构造器

在C#中,静态构造器是用来初始化任何静态数据。静态构造函数也称为“类构造函数”，由于类构造函数在生成的MSIL 里名为“.cctor”，因此也被称为“cctor”。
静态构造函数允许复杂的静态变量初始化。

静态构造函数在该类第一次被访问时调用，任何使用该类的操作（无论是调用静态函数、属性还是访问静态变量，还是构造类的实例）都会引发静态构造函数的执行。静态构造函数是线程安全的，并且是单例的。当用在泛型类中时，静态构造函数对于泛型的每个实例化都调用一次。静态变量也同样如此。
public class MyClass{
    private static int _A;

    // Normal constructor
    static MyClass()
    {
        _A = 32;
    }

    // Standard default constructor
    public MyClass()
    {

    }}
// Code somewhere// Instantiating an object with the constructor above// right before the instantiation// The variable static constructor is executed and _A is 32MyClass c = new MyClass();

C++

C++ 的构造函数以该类的类名为标识，且不写返回值类型也无法返回值：
class C{public:
  C(void){
    ...
  }};
构造函数的函数体执行是在各个成员构造完之后才开始，因此要想更改成员的构造方式需要使用成员初始化列表：
class B{public:
  std::string str;
  B(const char *psz): str(psz){
    ...
  }};
基类的方式与成员相同，是在初始化列表中写基类名、接构造函数参数表：
class D: public B{public:
  D(void): B("Hello, world!"){
    ...
  }};
复制构造函数接受同类对象的左值引用（一般为const T &）、移动构造函数接受右值引用（一般为T&&）：
class E{public:
  E(const E &e){...}//Copy constructor
  E(E &&e){...}//Move constructor};
C++ 中，程序员若未对某类定义构造函数（以及赋值函数、析构函数），编译器在满足条件时会定义相应的函数，参见  等页面。

CFML

component initmethod="Cheese" {
   // properties
   property name="cheeseName";

   // constructor
   function Cheese Cheese( required string cheeseName ) {
      variables.cheeseName = arguments.cheeseName;
      return this;
   }}

Object Pascal

program OopProgram;type
  TPerson = class
  private
    FName: string;
  public
    property Name: string read FName;
    constructor Create(AName: string);
  end;constructor TPerson.Create(AName: string);begin
  FName := AName;end;var
  Person: TPerson;begin
  Person := TPerson.Create('Peter'); // allocates an instance of TPerson and then calls TPerson.Create with the parameter AName = 'Peter'end.

Perl

package Person;# In Perl constructors are named 'new' by convention.sub new {
    # Class name is implicitly passed in as 0th argument.
    my $class = shift;

    # Default attribute values, if you have any.
    my %defaults = ( foo => "bar" );

    # Initialize attributes as a combination of default values and arguments passed.
    my $self = { %defaults, @_ };

    # Check for required arguments, class invariant, etc.
    if ( not defined $self->{first_name} ) {
        die "Mandatory attribute missing in Person->new(): first_name";
    }
    if ( not defined $self->{last_name} ) {
        die "Mandatory attribute missing in Person->new(): last_name";
    }
    if ( defined $self->{age} and $self->{age} < 18 ) {
        die "Invalid attribute value in Person->new(): age < 18";
    }

    # Perl makes an object belong to a class by 'bless'.
    bless $self, $class;
    return $self;}1;

Perl with Moose

package Person;# enable Moose-style object constructionuse Moose;# first name ( a string) can only be set at construction time ('ro')has first_name => (is => 'ro', isa => 'Str', required => 1);# last name ( a string) can only be set at construction time ('ro')has last_name  => (is => 'ro', isa => 'Str', required => 1);# age (Integer) can be modified after construction ('rw'), and is not required# to be passed to be constructor.  Also creates a 'has_age' method which returns# true if age has been sethas age        => (is => 'rw', isa => 'Int', predicate => 'has_age');# Check custom requirementssub BUILD {
      my $self = shift;
      if ($self->has_age && $self->age < 18) { # no under 18s
           die "No under-18 Persons";
      }}1;

PHP

class Person{
    private $name;

    public function __construct($name)
    {
        $this->name = $name;
    }

    public function getName()
    {
        return $this->name;
    }}

Python

>>> class ExampleClass(object):...     def __new__(cls, value):...         print("Creating new instance...")...         # Call the superclass constructor to create the instance....         instance = super(ExampleClass, cls).__new__(cls)...         return instance...     def __init__(self, value):...         print("Initialising instance...")...         self.payload = value>>> exampleInstance = ExampleClass(42)Creating new instance...Initialising instance...>>> print(exampleInstance.payload)42

Ruby

irb(main):001:0> class ExampleClassirb(main):002:1>   def initializeirb(main):003:2>     puts "Hello there"irb(main):004:2>   endirb(main):005:1> end=> nilirb(main):006:0> ExampleClass.newHello there=> #<ExampleClass:0x007fb3f4299118>