构造器

在類別基礎的物件導向程式設計中，建構子（英語： 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>