Yapıcı (nesne yönelimli programlama) - Constructor (object-oriented programming)

Olarak Sınıf tabanlı nesne yönelimli programlama , bir kurucu (kısaltma: ctor ) özel bir türü olan bir alt yordam çağrılır bir nesne oluşturmak . Yeni nesneyi kullanıma hazırlar, genellikle yapıcının gerekli üye değişkenlerini ayarlamak için kullandığı argümanları kabul eder .

Yapıcı bir örnek yöntemine benzer , ancak açık bir dönüş türüne sahip olmaması , örtük olarak miras alınmaması ve genellikle kapsam değiştiriciler için farklı kuralları olması bakımından bir yöntemden farklıdır . Yapıcılar genellikle bildiren sınıfla aynı ada sahiptir . Nesnenin veri üyelerini başlatma ve sınıfın değişmezini oluşturma, değişmez geçersizse başarısız olma görevine sahiptirler . Uygun şekilde yazılı yapıcı çıkan yaprakları nesneyi bir de geçerlidir devlet. Değişmez nesneler bir kurucuda başlatılmalıdır.

Çoğu dil , bir sınıf için farklı parametrelere sahip birden fazla kurucu olabileceğinden, yapıcının aşırı yüklenmesine izin verir . Bazı diller, bazı özel kurucu türlerini dikkate alır. Nesneleri oluşturmak ve sınıfın yeni bir örneğini döndürmek için somut olarak tek bir sınıfı kullanan yapıcılar , aynı zamanda nesneler yaratan ancak bunu birden çok sınıf veya nesne havuzu gibi farklı tahsis şemaları kullanarak çeşitli şekillerde yapabilen fabrikalar tarafından soyutlanır .

Türler

parametreli yapıcılar

En az bir argüman alabilen yapıcılar, parametreli yapıcılar olarak adlandırılır. Parametreli bir yapıcıda bir nesne bildirildiğinde, ilk değerlerin yapıcı işlevine argüman olarak iletilmesi gerekir. Nesne bildiriminin normal yolu çalışmayabilir. Yapıcılar açık veya örtük olarak çağrılabilir. Yapıcıyı örtük olarak çağırma yöntemine steno yöntemi de denir. Sınıfın alanlarını kendi değerlerinizle başlatmak istiyorsak, parametreli bir kurucu kullanın.

class Example {
 public:
  Example();
  Example(int a, int b);  // Parameterized constructor.

 private:
  int x_;
  int y_;
};

Example::Example() = default;

Example::Example(int x, int y) : x_(x), y_(y) {}

Example e = Example(0, 50);  // Explicit call.
Example e2(0, 50);  // Implicit call.

Varsayılan yapıcılar

Programcı, örneklenebilir bir sınıf için bir kurucu sağlamazsa, Java derleyicisi sizin adınıza kodunuza varsayılan bir kurucu ekler . Bu kurucu, varsayılan kurucu olarak bilinir. Derleme sırasında koda ekleneceği ve .class dosyasında bulunduğu için kaynak kodunuzda (java dosyası) bulamazsınız. Varsayılan yapıcının davranışı dile bağlıdır. Veri üyelerini sıfıra veya diğer aynı değerlere başlatabilir veya hiçbir şey yapmayabilir. Java'da "varsayılan kurucu", sınıf için herhangi bir kurucu tanımlanmamışsa veya programcı tarafından tanımlanmış herhangi bir kurucunun yokluğunda (örneğin Java'da, varsayılan kurucu örtük olarak derleyici tarafından otomatik olarak oluşturulan bir boş kurucuya atıfta bulunur. üst sınıfın null oluşturucusu, ardından boş bir gövde yürütür). Tüm alanlar, 0 (tamsayı türleri), 0.0 (kayan nokta türleri), false (boole türü) veya null (referans türleri) başlangıç ​​değerlerinde bırakılır.

#include <iostream>

class Student {
 public:
  Student(int a = 0, int b = 0);  // Default constructor.

  int a;
  int b;
};

Yapıcıları kopyala

C++ gibi Java da "Copy Constructor"ı destekler. Ancak, C++'tan farklı olarak, kendinizinkini yazmazsanız Java varsayılan bir kopya oluşturucu oluşturmaz. Kopyalama oluşturucuları, sınıf nesnelerini kopyalarken derleyici tarafından gerçekleştirilen eylemleri tanımlar. Bir Kopya oluşturucu, sınıfın türü olan bir resmi parametreye sahiptir (parametre bir nesneye referans olabilir). Aynı sınıftan var olan bir nesnenin bir kopyasını oluşturmak için kullanılır. Her iki sınıf da aynı olsa da, bir dönüştürme yapıcısı olarak sayılır. Kopya oluşturucular genellikle kısaltılmış kopya ctor veya cctor olsa da, aynı kısaltmayı kullanan .NET'te kullanılan sınıf oluşturucularla hiçbir ilgisi yoktur.

Dönüşüm oluşturucuları

Dönüştürme oluşturucuları, bir derleyicinin farklı türdeki bir nesneye dayalı olarak bir sınıfa ait bir nesneyi örtük olarak oluşturması için bir araç sağlar. Bu oluşturucular genellikle bağımsız değişkenleri veya işlenenleri uygun bir türe dönüştürmek için örtük olarak çağrılır, ancak açıkça çağrılabilirler.

Yapıcıları taşı

C++'da, move kurucuları sınıfın bir nesnesine bir değer referansı alır ve parametre nesnesinin kaynaklarının sahiplik transferini uygulamak için kullanılır.

Sözdizimi

• Java , C++ , C# , ActionScript , PHP 4 ve MATLAB , yapıcıların ilişkili oldukları sınıfla aynı ada sahip olduğu bir adlandırma kuralına sahiptir.
• PHP 5'te bir kurucu için önerilen isim __construct. Geriye dönük uyumluluk için, metot __constructbulunamazsa sınıfla aynı ada sahip bir metot çağrılır . PHP 5.3.3'ten bu yana, bu yalnızca ad alanlı olmayan sınıflar için çalışır.
• PHP 7'de yapıcıyı her zaman __construct. Sınıfla aynı ada sahip yöntemler, E_DEPRECATED düzeyinde bir hatayı tetikleyecektir.
• In Perl , kurucular "yeni" isimli kongre tarafından, ve nesne oluşturma adil bir miktar yapmak zorundayız.
• In Moose nesne sistemine Perl için, kurucular (adında yeni ) otomatik olarak oluşturulur ve bir belirtilerek uzatılır YAPI yöntemi.
• Gelen Visual Basic .NET , kurucu "denir New".
• In Python , yapıcı iki yöntem, "konusunda bölünmüş olduğunu __new__" ve " __init__". __new__Yöntem, örneğin bellek tahsis sorumludur ve (normal olarak "olarak adlandırılan bir değişken olarak sınıf alır cls. ") __init__(Genellikle "Başlatıcı" olarak adlandırılır) yöntemi (geleneksel olarak "olarak adlandırılan bir değişken olarak, yeni oluşturulan örneği geçirilir self").
• Nesne Pascal yapıcıları " constructor" anahtar sözcüğüyle belirtilir ve kullanıcı tanımlı adlara sahip olabilir (ancak çoğunlukla " Create" olarak adlandırılır ).
• Gelen amaç-C , yapıcı yöntemi iki yöntem boyunca bölünmüş olan, " alloc" ve " init" ile allocyöntem ayrılmasından sınıfın bir örneği için bellek (tahsis) ve initusul örneği başlatılıyor toplu taşıma. " new" yöntemine yapılan bir çağrı , sınıf örneği için hem yöntemleri hem allocde inityöntemleri çağırır .

Hafıza organizasyonu

Java, C# ve VB .NET'te yapıcı, " yığın " adı verilen özel bir bellek yapısında referans türü nesneler oluşturur . Değer türleri (int, double vb. gibi) " stack " adı verilen sıralı bir yapıda oluşturulur . VB .NET ve C#, değer türü nesneleri oluşturmak için yeni operatörün kullanılmasına da izin verir , ancak bu değer türü nesneler, operatörün kullanılıp kullanılmadığına bakılmaksızın yığın üzerinde oluşturulur.

C++'da nesneler, yapıcı new operatörü olmadan çağrıldığında yığında ve yapıcı yeni operatörle çağrıldığında öbek üzerinde oluşturulur. Yığın nesneleri kapsam dışına çıktıklarında örtük olarak silinirken, yığın nesneleri bir yıkıcı tarafından örtük olarak veya silme işleci kullanılarak açıkça silinmelidir .

Dil ayrıntıları

C++

In C ++ , yapıcı adı sınıfının adıdır. Hiçbir şey döndürmez. Herhangi bir üye işlevi gibi parametrelere sahip olabilir . Yapıcı işlevleri genellikle genel bölümde bildirilir, ancak kullanıcı bunlara erişimi kısıtlamak isterse korumalı ve özel bölümlerde de bildirilebilir.

Yapıcının iki bölümü vardır. Birincisi, parametre listesini izleyen ve yöntem gövdesinden önceki başlatıcı listesidir . İki nokta üst üste ile başlar ve girişler virgülle ayrılır. Başlatıcı listesi gerekli değildir, ancak veri üyeleri için değerler sağlama ve ayrı atama ifadelerinden kaçınma fırsatı sunar. Başlatıcı listesi, const veya başvuru türü veri üyeleriniz veya parametresiz oluşturucu mantığına sahip olmayan üyeleriniz varsa gereklidir . Atamalar, veri üyelerinin bildirildiği sıraya göre gerçekleşir (başlatıcı listesindeki sıra farklı olsa bile). İkinci kısım, küme parantezleri içine alınmış normal bir yöntem gövdesi olan gövdedir.

C++ birden fazla kurucuya izin verir. Diğer kurucular farklı parametrelere sahip olmalıdır. Ek olarak, varsayılan değerler verilen parametreleri içeren yapıcılar, tüm parametrelere varsayılan bir değer verilmediği kısıtlamasına uymalıdır. Bu, yalnızca varsayılan bir kurucu varsa önemli olan bir durumdur. Bir temel sınıfın (veya temel sınıfların) yapıcısı, türetilmiş bir sınıf tarafından da çağrılabilir. Yapıcı işlevleri devralınmaz ve adreslerine başvurulamaz. Bellek tahsisi gerektiğinde, yeni ve silme operatörleri dolaylı olarak çağrılır.

Bir kopya oluşturucu, const referans olarak geçirilen aynı türde bir parametreye sahiptir, örneğin Vector(const Vector& rhs) . Açıkça sağlanmazsa, derleyici her üye değişken için kopya oluşturucuyu kullanır veya ilkel türler olması durumunda değerleri kopyalar. Sınıf dinamik olarak ayrılmış üyelere sahipse (veya diğer kaynakları yönetiyorsa) varsayılan uygulama verimli değildir, çünkü yok edildiğinde silme için çift çağrıya (veya kaynakların iki kez serbest bırakılmasına) yol açabilir .

class Foobar {
 public:
  Foobar(double r = 1.0,
         double alpha = 0.0)  // Constructor, parameters with default values.
      : x_(r * cos(alpha))    // <- Initializer list
  {
    y_ = r * sin(alpha);  // <- Normal assignment
  }

 private:
  double x_;
  double y_;
};

Örnek çağrılar:

Foobar a,
       b(3),
       c(5, M_PI/4);

İşlevlerden nesnelerin döndürülmesi veya nesnelerin değerine göre geçirilmesi sırasında, dönüş değeri optimizasyonu uygulanmadığı sürece nesnelerin kopya yapıcısı örtük olarak çağrılır .

C++, programcı bir tane sağlamadıkça, kopya kurucuyu (klonlamayı önlemek için) açıkça siler veya temel sınıflardan veya üye değişkenlerden biri kopya kurucu silinmezse, tüm temel sınıflar ve tüm üye değişkenler için kopya kurucuları çağıracak örtük olarak bir varsayılan kopya kurucu oluşturur. veya erişilebilir değil (özel). Özelleştirilmiş bir kopya oluşturucuyu gerektiren çoğu durum (örneğin referans sayımı , işaretçilerin derin kopyası ) ayrıca yıkıcının ve kopya atama operatörünün özelleştirilmesini gerektirir . Bu genellikle Üçlü Kural olarak adlandırılır .

C#

Örnek C# yapıcısı:

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 above
MyClass c = new MyClass(42, "string");

C# statik oluşturucu

In C # , bir statik yapıcı statik veri başlatıcısı olduğunu. Statik kuruculara sınıf kurucuları da denir . Oluşturulan asıl yöntem .cctor adına sahip olduğundan, genellikle "ccctors" olarak da adlandırılırlar.

Statik oluşturucular, karmaşık statik değişken başlatmaya izin verir. Statik yapıcılar, sınıfa ilk erişildiğinde örtük olarak çağrılır. Bir sınıfa yapılan herhangi bir çağrı (statik veya yapıcı çağrısı), statik yapıcı yürütmesini tetikler. Statik oluşturucular iş parçacığı için güvenlidir ve tek bir desen uygular . Genel bir programlama sınıfında kullanıldığında , her yeni genel örneklemede her tür için bir tane olmak üzere statik oluşturucular çağrılır. Statik değişkenler de somutlaştırılır.

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 32
MyClass c = new MyClass();

CFML

CFML , inityapıcı yöntem olarak ' ' adlı bir yöntem kullanır .

peynir.cfc

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

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

Bir peynir örneği oluşturun.

myCheese = new Cheese( 'Cheddar' );

ColdFusion 10'dan beri CFML, yapıcı yönteminin adının belirtilmesini de desteklemiştir:

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

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

Eyfel

In Eiffel , yeni nesneler başlatmak rutinleri denir oluşturma prosedürleri . Oluşturma prosedürleri aşağıdaki özelliklere sahiptir:

• Oluşturma prosedürlerinin açık bir dönüş türü yoktur ( prosedür tanımına göre ).
• Oluşturma prosedürleri adlandırılmıştır.
• Oluşturma prosedürleri, sınıf metninde oluşturma prosedürleri olarak adla belirtilir.
• Varolan nesneleri yeniden başlatmak için oluşturma prosedürleri açıkça çağrılabilir.
• Her etkili (yani, somut veya soyut olmayan) sınıf, en az bir oluşturma prosedürü belirlemelidir.
• Oluşturma prosedürleri, yeni başlatılan nesneyi sınıf değişmezini karşılayan bir durumda bırakmalıdır.

Nesne oluşturma bazı incelikler içerse x: Tde, oluşturma talimatında ifade edildiği gibi tipik bir bildirime sahip bir özniteliğin oluşturulması create x.makeaşağıdaki adımlardan oluşur:

• Yeni bir doğrudan tür örneği oluşturun T.
• makeYeni oluşturulan örneğe oluşturma prosedürünü yürütün .
• Yeni başlatılan nesneyi varlığa ekleyin x.

Aşağıdaki ilk snippet'te sınıf POINTtanımlanmıştır. Prosedür make, anahtar kelimeden sonra kodlanmıştır feature.

Anahtar sözcük create, örnekleri başlatmak için kullanılabilecek bir prosedürler listesi sunar. Bu durumda liste içerir default_create, sınıftan miras boş uygulanmasıyla ilgili bir prosedür ANYve makesınıf içindeki kodlu prosedür.

class
    POINT
create
    default_create, make

feature

    make (a_x_value: REAL; a_y_value: REAL)
        do
            x := a_x_value
            y := a_y_value
        end

    x: REAL
            -- X coordinate

    y: REAL
            -- Y coordinate
        ...

İkinci snippet'te, POINTbildirimleri olan my_point_1ve my_point_2türünde bir istemci olan bir sınıf POINT.

Prosedürel kodda, my_point_1orijin (0.0, 0.0) olarak oluşturulur. Herhangi bir oluşturma prosedürü belirtilmediğinden, default_createsınıftan miras alınan prosedür ANYkullanılır. Bu satır kodlanmış olabilir create my_point_1.default_create. createAnahtar kelime ile bir talimatta yalnızca oluşturma prosedürleri olarak adlandırılan prosedürler kullanılabilir . Sonraki, 'nin koordinatları my_point_2için başlangıç ​​değerleri sağlayan bir oluşturma talimatıdır my_point_2. Üçüncü talimat, makeekli örneği my_point_2farklı değerlerle yeniden başlatmak için prosedüre sıradan bir örnek çağrısı yapar .

    my_point_1: POINT
    my_point_2: POINT
        ...

            create my_point_1
            create my_point_2.make (3.0, 4.0)
            my_point_2.make (5.0, 8.0)
        ...

F#

In F # , bir yapıcı herhangi içerebilir letveya dosınıf içerisinde tanımlanan ifadeleri. letdeyimler özel alanları tanımlar ve dodeyimler kodu yürütür. newAnahtar kelime kullanılarak ek kurucular tanımlanabilir .

type MyClass(_a : int, _b : string) = class
    // Primary constructor
    let a = _a
    let b = _b
    do printfn "a = %i, b = %s" a b

    // Additional constructors
    new(_a : int) = MyClass(_a, "") then
        printfn "Integer parameter given"

    new(_b : string) = MyClass(0, _b) then
        printfn "String parameter given"

    new() = MyClass(0, "") then
        printfn "No parameter given"
end

// Code somewhere
// instantiating an object with the primary constructor
let c1 = new MyClass(42, "string")

// instantiating an object with additional constructors
let c2 = new MyClass(42)
let c3 = new MyClass("string")
let c4 = MyClass() // "new" keyword is optional

Java

In Java , kurucuların diğer yöntemlerden farklı:

• Yapıcılar hiçbir zaman açık bir dönüş türüne sahip değildir.
• Yapıcılar doğrudan çağrılamaz (“ new” anahtar sözcüğü onları çağırır).
• Yapıcılar erişim dışı değiştiricilere sahip olmamalıdır.

Java yapıcıları aşağıdaki görevleri aşağıdaki sırayla gerçekleştirir:

1. Tanımlanmış bir kurucu yoksa, üst sınıfın varsayılan kurucusunu çağırın.
2. Üye değişkenleri belirtilen değerlere sıfırlayın.
3. Yapıcının gövdesini yürütür.

Java, kullanıcıların bir kurucuyu başka bir kurucuda this()anahtar kelime kullanarak çağırmasına izin verir . Ama this()ilk ifade olmalı.

class Example
{ 
    Example() // Non-parameterized constructor
    {
        this(1);  // Calling of constructor
        System.out.println("0-arg-cons");
    }
    Example(int a) // Parameterized constructor
    {
        System.out.println("1-arg-cons");
    }
}
public static void main(String[] args)
{
  Example e = new Example();
}

Java, üst sınıfın yapıcısına superanahtar kelime aracılığıyla erişim sağlar .

public class Example
{
    // Definition of the constructor.
    public Example()
    {
        this(1);
    }

    // Overloading a constructor
    public Example(int input)
    {
        data = input; // This is an assignment
    }

    // Declaration of instance variable(s).
    private int data;
}

// Code somewhere else
// Instantiating an object with the above constructor
Example e = new Example(42);

Sıfır sayıda argüman alan bir kurucuya "argümansız" veya "argmansız" kurucu denir.

JavaScript

ES6'dan itibaren JavaScript , diğer birçok programlama dili gibi doğrudan kuruculara sahiptir. bunlar böyle yazılır

class FooBar {
  constructor(baz) {
    this.baz = baz
  }
}

Bu şu şekilde somutlaştırılabilir

const foo = new FooBar('7')

Bunun ES6'dan önceki karşılığı, bir nesneyi şu şekilde başlatan bir işlev yaratmaktı.

function FooBar (baz) {
  this.baz = baz;
}

Bu, yukarıdakiyle aynı şekilde somutlaştırılır.

Nesne Pascal

In Object Pascal , yapıcı bir benzer fabrika yöntemiyle . Normal yöntemlerden tek sözdizimsel fark constructor, adın önündeki anahtar kelimedir ( procedureveya yerine function). Herhangi bir ada sahip olabilir, ancak sözleşmede olduğu Creategibi önek olması gerekir CreateWithFormatting. Bir sınıfın örneğini oluşturmak, bir sınıfın statik yöntemini çağırmak gibi çalışır: TPerson.Create('Peter').

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.

OCaml

In OCaml , bir kurucu yoktur. Parametreler sınıf adından hemen sonra tanımlanır. Örnek değişkenleri başlatmak için kullanılabilirler ve sınıf boyunca erişilebilirler. Çağrılan anonim bir gizli yöntem initializer, nesne oluşturulduktan hemen sonra bir ifadenin değerlendirilmesine izin verir.

class person first_name last_name =
  object
    val full_name = first_name ^ " " ^ last_name

    initializer
      print_endline("Hello there, I am " ^ full_name ^ ".")

    method get_last_name = last_name
  end;;

let alonzo = new person "Alonzo" "Church" in (*Hello there, I am Alonzo Church.*)

print_endline alonzo#get_last_name (*Church*)

PHP

In PHP sürümü 5 ve üzeri, yapıcı adında bir yöntemdir __construct()anahtar kelime (bir çift alt çizgi olduğunu haber) newotomatik olarak nesneyi oluşturduktan sonra çağırır. Genellikle, özellik başlatmaları gibi başlatmaları otomatik olarak gerçekleştirmek için kullanılır. Yapıcılar argümanları da kabul edebilir, bu durumda newifade yazıldığında, parametreler için yapıcı argümanlarını da göndermeniz gerekir.

class Person
{
    private string $name;

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

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

Perl 5

In Perl dili programlama varsayılan olarak, sürüm 5, kurucular fabrika yöntemleri vardır, somut olarak oluşturmak ve mübarek başvuru döndürmek anlamına oluşturmak ve nesneyi döndürmek yöntemleri. Tipik bir nesne, bir karmaya referanstır, ancak nadiren diğer türlere referanslar da kullanılır. Konvansiyonel olarak, tek kurucu new olarak adlandırılır , ancak başka şekilde adlandırılmasına veya birden çok kurucuya sahip olmasına izin verilir. Örneğin, bir Person sınıfı, new adlı bir kurucunun yanı sıra , Person nitelikleri için bir dosya okuyan new_from_file yapıcısına ve şablon olarak başka bir Person nesnesini kullanan new_from_person adlı bir kurucuya sahip olabilir.

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;

Moose ile Perl 5

Perl için Moose nesne sistemi ile, bu genel bilgilerin çoğu dışarıda bırakılabilir, varsayılan bir yeni oluşturulur, öznitelikler belirtilebilir ve bunların ayarlanabileceği, sıfırlanıp ayarlanamayacağı veya gerekli olup olmadığı belirtilebilir. Ek olarak, herhangi bir ekstra yapıcı işlevi , bağımsız değişkenleri kontrol ettikten sonra Moose tarafından oluşturulan yapıcının çağıracağı bir BUILD yöntemine dahil edilebilir . Hashref / key => değer biçiminde olmayan yapıcı argümanlarını işlemek için bir BUILDARGS yöntemi belirtilebilir.

package Person;
# enable Moose-style object construction
use 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 set
has age        => (is => 'rw', isa => 'Int', predicate => 'has_age');

# Check custom requirements
sub BUILD {
      my $self = shift;
      if ($self->has_age && $self->age < 18) { # no under 18s
           die "No under-18 Persons";
      }
}
1;

Her iki durumda da Person sınıfı şu şekilde başlatılır:

use Person;
my $p = Person->new( first_name => 'Sam', last_name => 'Ashe', age => 42 );

piton

Gelen Python , yapıcı bir ya da her ikisinin ile tanımlanır __new__ve __init__yöntemler. Sınıf, __new__ve __init__yöntemlerini çağıran bir işlevmiş gibi çağırılarak yeni bir örnek oluşturulur . Sınıfta bir yapıcı yöntemi tanımlanmamışsa, sınıfın Yöntem Çözüm Sırasında bulunan bir sonraki yöntem çağrılır.

Tipik durumda, yalnızca __init__yöntemin tanımlanması gerekir. (En yaygın istisna, değişmez nesneler içindir.)

>>> class ExampleClass:
...     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

Sınıflar normalde kendilerinin yeni örnekleri için fabrikalar gibi davranır , yani bir sınıf çağrılabilir bir nesnedir (bir işlev gibi), çağrı yapıcıdır ve sınıfın çağrılması o sınıfın bir örneğini döndürür. Bununla birlikte, __new__yöntemin, özel amaçlar için sınıfın bir örneğinden başka bir şey döndürmesine izin verilir. Bu durumda, __init__çağrılmaz.

Raku

İle Raku , hatta daha klişe varsayılan bir göz önüne alındığında, dışarı bırakılabilir yeni yöntem, devralınan nitelikleri belirtilebilir yanı onlar, set sıfırlama veya gerekli olabilir olmadığı gibi. Ek olarak, herhangi bir ekstra yapıcı işlevi, özel başlatmaya izin vermek için çağrılacak olan bir BUILD yöntemine dahil edilebilir . Halihazırda (dolaylı olarak) başlatılan tüm öznitelikleri sonradan işlemek için bir TWEAK yöntemi belirtilebilir.

class Person {
    has Str $.first-name is required; # First name (a string) can only be set at
                                      # construction time (the . means "public").
    has Str $.last-name is required;  # Last name (a string) can only be set at
                                      # construction time (a ! would mean "private").
    has Int $.age is rw;              # Age (an integer) can be modified after 
                                      # construction ('rw'), and is not required
                                      # during the object instantiation.
    
    # Create a 'full-name' method which returns the person's full name.
    # This method can be accessed outside the class.
    method full-name { $!first-name.tc ~ " " ~ $!last-name.tc }

    # Create a 'has-age' method which returns true if age has been set.
    # This method is used only inside the class so it's declared as "private"
    # by prepending its name with a !
    method !has-age { self.age.defined }
  
    # Check custom requirements
    method TWEAK {
        if self!has-age && $!age < 18 { # No under 18
            die "No person under 18";
        }
    }
}

Person sınıfı şu şekilde somutlaştırılır:

my $p0 = Person.new( first-name => 'Sam', last-name => 'Ashe', age => 42 );
my $p1 = Person.new( first-name => 'grace', last-name => 'hopper' );
say $p1.full-name(); # OUTPUT: «Grace Hopper␤»

Alternatif olarak, adlandırılmış parametreler Perl 6'daki iki nokta üst üste çift sözdizimi kullanılarak belirtilebilir:

my $p0 = Person.new( :first-name<Sam>, :last-name<Ashe>, :age(42) );
my $p1 = Person.new( :first-name<Grace>, :last-name<Hopper> );

Ve eğer kullanacağı bir kısayol kullanabilirsiniz adlı parametrelere özdeş adlarla değişkenleri kurmak olmalıydı isim adındaki parametre için değişkenin:

my $first-name = "Sam";
my $last-name  = "Ashe";
my $age        = 42;
my $p0 = Person.new( :$first-name, :$last-name, :$age );

yakut

In Ruby , kurucular olarak adlandırılan bir yöntem tanımlayarak oluşturulur initialize. Bu yöntem, her yeni örneği başlatmak için yürütülür.

irb(main):001:0> class ExampleClass
irb(main):002:1>   def initialize
irb(main):003:2>     puts "Hello there"
irb(main):004:2>   end
irb(main):005:1> end
=> nil
irb(main):006:0> ExampleClass.new
Hello there
=> #<ExampleClass:0x007fb3f4299118>

Visual Basic .NET

Gelen Visual Basic .NET , kurucular adı "ile bir metot beyanı kullanmak New".

Class Foobar
    Private strData As String

    ' Constructor
    Public Sub New(ByVal someParam As String)
        strData = someParam
    End Sub
End Class

' code somewhere else
' instantiating an object with the above constructor
Dim foo As New Foobar(".NET")

Ayrıca bakınız

• RAII
• tahsis yeri
• Yaratıcı desen
• Yıkıcı
• C++'da genel kurucu ve onun C karşılığı, ((yapıcı)) işlev özelliği

Notlar

Referanslar