Konstruktor (objektově orientované programování) - Constructor (object-oriented programming)

v třídní objektově orientované programování, a konstruktor (zkratka: ctor) je speciální typ podprogram volal na vytvořit objekt. Připravuje nový objekt k použití, často přijímá argumenty které konstruktor používá k nastavení required členské proměnné.

Konstruktor se podobá metoda instance, ale liší se od metody v tom, že nemá explicitní návratový typ, není to implicitně zdědil a obvykle má různá pravidla pro modifikátory rozsahu. Konstruktory mají často stejný název jako deklarace třída. Mají za úkol inicializace objekt datové členy a založení invariant třídy, pokud není invariant neplatný. Správně napsaný konstruktor ponechává výsledný objekt v platný Stát. Neměnné objekty musí být inicializován v konstruktoru.

Většina jazyků to umožňuje přetížení konstruktor v tom, že pro třídu může existovat více než jeden konstruktor s různými parametry. Některé jazyky berou v úvahu některé speciální typy konstruktorů. Konstruktory, které konkrétně používají jedinou třídu k vytváření objektů a návratu nové instance třídy, jsou abstrahovány pomocí továrny, které také vytvářejí objekty, ale mohou tak činit různými způsoby, pomocí více tříd nebo různých schémat alokace, jako je fond objektů.

Typy

Parametrizované konstruktory

Konstruktory, které mohou mít alespoň jeden argument, se nazývají jako parametrizované konstruktory. Když je objekt deklarován v parametrizovaném konstruktoru, musí být počáteční hodnoty předány jako argumenty funkci konstruktoru. Normální způsob deklarace objektu nemusí fungovat. Konstruktory lze volat explicitně nebo implicitně. Metoda implicitního volání konstruktoru se také nazývá zkratková metoda. Pokud chceme inicializovat pole třídy s vašimi vlastními hodnotami, použijte parametrizovaný konstruktor.

třída Příklad { veřejnost:  Příklad();  Příklad(int A, int b);  // Parametrizovaný konstruktor. soukromé:  int X_;  int y_;};Příklad::Příklad() = výchozí;Příklad::Příklad(int X, int y) : X_(X), y_(

Příklad E = Příklad(0, 50);  // Explicitní volání.Příklad e2(0, 50);  // Implicitní volání.

Výchozí konstruktory

Pokud programátor nedodá konstruktor pro instantní třídu, vloží kompilátor Java a výchozí konstruktor do vašeho kódu vaším jménem. Tento konstruktor je známý jako výchozí konstruktor. Ve zdrojovém kódu (soubor java) jej nenajdete, protože by byl vložen do kódu během kompilace a existuje v souboru .class. Chování výchozího konstruktoru závisí na jazyce. Může inicializovat datové členy na nulu nebo jiné stejné hodnoty, nebo nemusí dělat vůbec nic. V Javě se „výchozím konstruktorem“ rozumí nulární konstruktor, který je automaticky generován kompilátorem, pokud pro třídu nejsou definovány žádné konstruktory nebo pokud neexistují žádné konstruktory definované programátorem (např. V Javě implicitní konstruktor volá implicitně nadřazený konstruktor nully, poté provede prázdné tělo). Všechna pole jsou ponechána na počáteční hodnotě 0 (celočíselné typy), 0,0 (typy s plovoucí desetinnou čárkou), false (booleovský typ) nebo null (referenční typy).

#zahrnout <iostream>třída Student { veřejnost:  Student(int A = 0, int b = 0);  // Výchozí konstruktor.  int A;  int b;};

Kopírovat konstruktory

Stejně jako C ++ podporuje Java také „Copy Constructor“. Ale na rozdíl od C ++ Java nevytváří výchozí konstruktor kopírování, pokud nepíšete svůj vlastní. Konstruktory kopírování definují akce prováděné kompilátorem při kopírování objektů třídy. Konstruktor Copy má jeden formální parametr, který je typem třídy (parametrem může být odkaz na objekt). Používá se k vytvoření kopie existujícího objektu stejné třídy. I když jsou obě třídy stejné, počítá se to jako konstruktor převodu. Zatímco konstruktory kopírování jsou obvykle zkrácené copy nebo cctor, nemají nic společného s konstruktory třídy používanými v .NET pomocí stejné zkratky.

Konstruktory převodu

Konstruktory převodu poskytují kompilátoru prostředek k implicitnímu vytvoření objektu patřícího do jedné třídy na základě objektu jiného typu. Tyto konstruktory jsou obvykle vyvolány implicitně k převodu argumentů nebo operandů na vhodný typ, ale mohou být také volány explicitně.

Přesuňte konstruktory

V C ++, přesunout konstruktory vzít odkaz na hodnotu objektu třídy a slouží k implementaci převodu vlastnictví prostředků objektu parametru.

Syntax

• Jáva, C ++, C#, ActionScript, PHP 4 a MATLAB mají konvenci pojmenování, ve které mají konstruktéři stejný název jako třída, se kterou jsou spojeni.
• V PHP 5 je doporučený název pro konstruktor __postavit. Pro zpětnou kompatibilitu bude volána metoda se stejným názvem jako třída if __postavit metodu nelze najít. Od PHP 5.3.3 to funguje pouze pro třídy bez jmen.^[1]
• V PHP 7 byste měli vždy pojmenovat konstruktor jako __postavit. Metody se stejným názvem jako třída spustí chybu úrovně E_DEPRECATED.^[1]
• v Perl, konstruktéři jsou podle konvence pojmenováni „noví“ a musí dělat slušné množství vytváření objektů.
• v Moose objektový systém pro Perl, konstruktéři (pojmenovaní Nový) se automaticky vytvoří a rozšíří se zadáním a STAVĚT metoda.
• v Visual Basic .NET, konstruktor se nazývá "Nový".
• v Krajta, konstruktor je rozdělen na dvě metody, "__Nový__" a "__init__" __Nový__ metoda je zodpovědná za přidělení paměti pro instanci a přijímá třídu jako argument (běžně nazývaný „cls") __init__ metoda (často nazývaná „inicializátor“) se předává nově vytvořené instanci jako argument (běžně nazývané „já").^[2]
• Objekt Pascal konstruktory jsou označeny klíčovým slovem „konstruktor"a může mít uživatelsky definované názvy (ale většinou se nazývají"Vytvořit").
• v Cíl-C, metoda konstruktoru je rozdělena do dvou metod, "alokace" a "inic"s alokace metoda vyčlenění (přidělení) paměti pro instanci třídy a inic metoda manipulace s velikostí inicializace instance. Volání metody "Nový"vyvolá obě alokace a inic metody pro instanci třídy.

Organizace paměti

V Javě, C # a VB .NET vytváří konstruktor objekty referenčního typu ve speciální struktuře paměti zvané „halda ". Typy hodnot (například int, double atd.) Jsou vytvářeny v sekvenční struktuře zvané" "zásobník ".VB .NET a C # také umožňují použití Nový operátor k vytvoření objektů typu hodnoty, ale tyto objekty typu hodnoty jsou vytvořeny v zásobníku bez ohledu na to, zda je operátor použit nebo ne.

V C ++ se objekty vytvářejí na zásobníku, když je konstruktor vyvolán bez nového operátoru, a jsou vytvořeny na haldě, když je konstruktor vyvolán novým operátorem. Stack objekty jsou odstraněny implicitně, když jdou mimo rozsah, zatímco haldy objekty musí být odstraněny implicitně destruktorem nebo explicitně pomocí vymazat operátor.

Jazykové podrobnosti

Bylo navrženo, aby tento článek byl rozdělit do nového článku s názvem Porovnání programovacích jazyků (OOP, konstruktory). (Diskutujte) (Květen 2016)

Jáva

v Jáva, konstruktory se liší od ostatních metod v tom, že:

• Konstruktory nikdy nemají explicitní návratový typ.
• Konstruktory nelze přímo vyvolat (klíčové slovo „Nový”Je vyvolává).
• Konstruktory nemohou být synchronizované, finále, abstraktní, rodáknebo statický.
• Neměl by obsahovat modifikátory

Konstruktory jazyka Java provádějí následující úkoly v následujícím pořadí:

1. Pokud není definován žádný konstruktor, zavolejte výchozí konstruktor nadtřídy.
2. Inicializujte členské proměnné na zadané hodnoty.
3. Spustí tělo konstruktoru.

Java umožňuje uživatelům volat jeden konstruktor v jiném konstruktoru pomocí tento() klíčové slovo tento() musí být první výrok. ^[3]

třída Příklad{     Příklad() // Neparametrický konstruktor    {        tento(1);  // Volání konstruktoru        Systém.ven.tisk(„0-arg-cons“);    }    Příklad(int A) // Parametrizovaný konstruktor    {        Systém.ven.tisk(„1-arg-cons“);    }}veřejnost statický prázdnota hlavní(Tětiva[] args){  Příklad E = Nový Příklad();}

Java poskytuje přístup k nadtřídy konstruktor prostřednictvím super klíčové slovo.

veřejnost třída Příklad{    // Definice konstruktoru.    veřejnost Příklad()    {        tento(1);    }    // Přetížení konstruktoru    veřejnost Příklad(int vstup)    {        data = vstup; // Toto je úkol    }    // Deklarace proměnných instance.    soukromé int data;}

// Kód někde jinde// Vytvoření instance objektu pomocí výše uvedeného konstruktoruPříklad E = Nový Příklad(42);

Konstruktor, který přijímá nulový počet argumentů, se nazývá konstruktor „no-arguments“ nebo „no-arg“.^[4]

JavaScript

Od verze ES6 JavaScript má přímé konstruktory jako mnoho jiných programovacích jazyků. Jsou psány jako takové

třída FooBar {  konstruktor(baz) {    tento.baz = baz  }}

To může být vytvořeno jako takové

konst foo = Nový FooBar('7')

Ekvivalentem tohoto před ES6 bylo vytvoření funkce, která vytvoří instanci objektu jako takového

funkce FooBar (baz) {  tento.baz = baz;}

Toto je vytvořeno stejným způsobem jako výše.

Visual Basic .NET

v Visual Basic .NET, konstruktéři používají deklaraci metody s názvem "Nový".

Třída Foobar    Soukromé strData Tak jako Tětiva    „Konstruktor    Veřejnost Sub Nový(ByVal někteříParam Tak jako Tětiva)        strData = někteříParam    Konec SubKonec Třída

'kód někde jinde'vytvoření instance objektu pomocí výše uvedeného konstruktoruZtlumit foo Tak jako Nový Foobar(".SÍŤ")

C#

Příklad C# konstruktor:

veřejnost třída Moje třída{    soukromé int A;    soukromé tětiva b;    // Konstruktor    veřejnost Moje třída() : tento(42, "tětiva")    {    }    // Přetížení konstruktoru    veřejnost Moje třída(int A, tětiva b)    {        tento.A = A;        tento.b = b;    }}

// Někde kód// Vytvoření instance objektu pomocí konstruktoru výšeMoje třída C = Nový Moje třída(42, "tětiva");

C # statický konstruktor

v C#, a statický konstruktor je inicializátor statických dat. Statické konstruktory se také nazývají konstruktory třídy. Protože skutečná vygenerovaná metoda má název .cctor často se jim také říká „léčitelé“.^[5][6]

Statické konstruktory umožňují inicializaci složitých statických proměnných.^[7]Statické konstruktory se implicitně volají při prvním přístupu ke třídě. Jakékoli volání třídy (statické nebo konstruktorové volání), spustí spuštění statického konstruktoru. Statické konstruktory jsou bezpečné pro vlákna a implementovat singletonový vzor. Při použití v generické programování třídy, statické konstruktory jsou volány při každé nové generické instanci pro každý typ. Jsou také vytvořeny instance statických proměnných.

veřejnost třída Moje třída{    soukromé statický int _A;    // Normální konstruktor    statický Moje třída()    {        _A = 32;    }    // Standardní výchozí konstruktor    veřejnost Moje třída()    {    }}

// Někde kód// Vytvoření instance objektu pomocí konstruktoru výše// těsně před vytvořením instance// Proměnný statický konstruktor je spuštěn a _A je 32Moje třída C = Nový Moje třída();

C ++

v C ++, název konstruktoru je název třídy. Nic nevrací. Může mít parametry jako všechny ostatní členské funkce. Funkce konstruktoru jsou obvykle deklarovány ve veřejné sekci, ale mohou být deklarovány také v chráněné a soukromé sekci, pokud chce uživatel omezit přístup k nim.

Konstruktor má dvě části. První je seznam inicializátorů který následuje po seznam parametrů a před tělem metody. Začíná to dvojtečkou a položky jsou odděleny čárkou. Seznam inicializátoru není vyžadován, ale nabízí příležitost poskytnout hodnoty pro datové členy a vyhnout se samostatným příkazům přiřazení. Seznam inicializátorů je vyžadován, pokud máte konst nebo datové členy referenčního typu nebo členové, kteří nemají logiku konstruktoru bez parametrů. Přiřazení probíhá podle pořadí, ve kterém jsou datové členy deklarovány (i když je pořadí v seznamu inicializátorů jiné).^[8] Druhou částí je tělo, což je tělo normální metody uzavřené ve složených závorkách.

C ++ umožňuje více než jednoho konstruktora. Ostatní konstruktory musí mít různé parametry. Navíc konstruktory, které obsahují parametry, kterým jsou dány výchozí hodnoty, musí dodržovat omezení, že ne všem parametrům je dána výchozí hodnota. Jedná se o situaci, na které záleží, pouze pokud existuje výchozí konstruktor. Konstruktor a základní třída (nebo základní třídy) lze také volat odvozenou třídou. Funkce konstruktoru nejsou zděděny a na jejich adresy nelze odkazovat. Pokud je vyžadováno přidělení paměti, Nový a vymazat operátoři jsou voláni implicitně.

Konstruktor kopie má předán parametr stejného typu jako konst odkaz, například Vektor (const Vector a další). Pokud to není poskytnuto explicitně, kompilátor používá konstruktor kopírování pro každou členskou proměnnou nebo jednoduše zkopíruje hodnoty v případě primitivních typů. Výchozí implementace není efektivní, pokud má třída dynamicky přidělené členy (nebo zpracovává jiné zdroje), protože může vést k dvojitému volání vymazat (nebo dvojité uvolnění zdrojů) po zničení.

třída Foobar { veřejnost:  Foobar(dvojnásobek r = 1.0,         dvojnásobek alfa = 0.0)  // Konstruktor, parametry s výchozími hodnotami.      : X_(r * cos(alfa))    // <- Seznam inicializátorů  {    y_ = r * hřích(alfa);  // <- Normální přiřazení  } soukromé:  dvojnásobek X_;  dvojnásobek y_;};

Příklad vyvolání:

Foobar A,       b(3),       C(5, M_PI/4);

Při vracení objektů z funkcí nebo předávání objektů podle hodnoty bude konstruktor kopírování objektů implicitně volán, pokud optimalizace návratové hodnoty platí.

C ++ implicitně generuje výchozí konstruktor kopírování, který bude volat konstruktory kopírování pro všechny základní třídy a všechny členské proměnné, pokud programátor neposkytne jeden, explicitně odstraní konstruktor kopírování (aby se zabránilo klonování) nebo se odstraní jedna ze základních tříd nebo členské proměnné kopírující konstruktor nebo není přístupný (soukromý). Většina případů vyžaduje přizpůsobení kopírovací konstruktor (např. počítání referencí, hluboká kopie of pointers) také vyžadují přizpůsobení destruktor a operátor přiřazení kopie. Toto se běžně označuje jako Pravidlo tří.

F#

v F#, konstruktor může zahrnovat libovolný nechat nebo dělat příkazy definované ve třídě. nechat příkazy definují soukromá pole a dělat příkazy provést kód. Další konstruktory lze definovat pomocí Nový klíčové slovo.

typ Moje třída(_A : int, _b : tětiva) = třída    // Primární konstruktor    nechat A = _A    nechat b = _b    dělat printfn „a =% i, b =% s“ A b    // Další konstruktory    Nový(_A : int) = Moje třída(_A, "") pak        printfn "Je zadán celočíselný parametr"    Nový(_b : tětiva) = Moje třída(0, _b) pak        printfn "Byl zadán řetězecový parametr"    Nový() = Moje třída(0, "") pak        printfn „Není zadán žádný parametr“konec

// Někde kód// vytvoření instance objektu pomocí primárního konstruktorunechat c1 = Nový Moje třída(42, "tětiva")// vytvoření instance objektu s dalšími konstruktorynechat c2 = Nový Moje třída(42)nechat c3 = Nový Moje třída("tětiva")nechat c4 = Moje třída() // „nové“ klíčové slovo je volitelné

Eiffelova

v Eiffelova se nazývají rutiny, které inicializují nové objekty postupy vytváření. Postupy vytváření mají následující vlastnosti:

• Procedury vytváření nemají žádný explicitní návratový typ (podle definice postup).^[A]
• Postupy vytváření jsou pojmenovány.
• Postupy vytváření jsou v textu třídy pojmenovány jako postupy vytváření.
• K opětovné inicializaci existujících objektů lze explicitně vyvolat postupy vytváření.
• Každá efektivní (tj. Konkrétní nebo neabstraktní) třída musí určit alespoň jeden postup vytváření.
• Procedury vytváření musí ponechat nově inicializovaný objekt ve stavu, který splňuje invariant třídy.^[b]

Ačkoli vytváření objektů zahrnuje některé jemnosti,^[9] vytvoření atributu s typickou deklarací x: T jak je vyjádřeno v pokynu k vytvoření vytvořit x.make sestává z následující posloupnosti kroků:

• Vytvořte novou přímou instanci typu T.^[C]
• Proveďte postup vytvoření udělat do nově vytvořené instance.
• Připojte nově inicializovaný objekt k entitě X.

V prvním úryvku níže třída SMĚŘOVAT je definováno. Postup udělat je kódováno za klíčovým slovem Vlastnosti.

Klíčové slovo vytvořit zavádí seznam postupů, které lze použít k inicializaci instancí. V tomto případě seznam obsahuje default_create, procedura s prázdnou implementací zděděnou od třídy ŽÁDNÝa udělat postup kódovaný ve třídě.

třída    SMĚŘOVATvytvořit    default_create, udělatVlastnosti    udělat (a_x_value: NEMOVITÝ; a_y_value: NEMOVITÝ)        dělat            X := a_x_value            y := a_y_value        konec    X: NEMOVITÝ            - X souřadnice    y: NEMOVITÝ            - Souřadnice Y        ...

Ve druhém úryvku třída, která je klientem SMĚŘOVAT má prohlášení my_point_1 a my_point_2 typu SMĚŘOVAT.

V procedurálním kódu my_point_1 je vytvořen jako počátek (0,0, 0,0). Protože není zadán žádný postup vytváření, postup default_create zdědil od třídy ŽÁDNÝ se používá. Tato linka mohla být kódována vytvořit my_point_1.default_create V pokynu s. Lze použít pouze postupy pojmenované jako procedury vytváření vytvořit keyword.Next je návod k vytvoření pro my_point_2, poskytující počáteční hodnoty pro my_point_2Třetí instrukce provede volání běžné instance na udělat postup reinicializace instance připojené k my_point_2 s různými hodnotami.

    my_point_1: SMĚŘOVAT    my_point_2: SMĚŘOVAT        ...            vytvořit my_point_1            vytvořit my_point_2.udělat (3.0, 4.0)            my_point_2.udělat (5.0, 8.0)        ...

CFML

CFML používá metodu s názvem 'inic„jako metoda konstruktoru.

Sýr. Cfc

součástka {   // vlastnosti   vlastnictví název=„název sýra“;   // konstruktor   funkce Sýr inic( Požadované tětiva název sýra ) {      proměnné.název sýra = argumenty.název sýra;      vrátit se tento;   }}

Vytvořte instanci sýra.

můj sýr = Nový Sýr( 'Čedar' );

Od ColdFusion 10,^[10] CFML také podporoval zadání názvu metody konstruktoru:

součástka počáteční metoda="Sýr" {   // vlastnosti   vlastnictví název=„název sýra“;   // konstruktor   funkce Sýr Sýr( Požadované tětiva název sýra ) {      proměnné.název sýra = argumenty.název sýra;      vrátit se tento;   }}

Objekt Pascal

v Objekt Pascal, konstruktor je podobný a tovární metoda. Jediným syntaktickým rozdílem oproti běžným metodám je klíčové slovo konstruktor před jménem (místo postup nebo funkce). Může mít jakékoli jméno, i když konvence má být Vytvořit jako předpona, například v CreateWithFormatting. Vytvoření instance třídy funguje jako volání statické metody třídy: TPerson.Create ('Peter').

program OopProgram;typ  TPerson = třída  soukromé    FName: tětiva;  veřejnost    vlastnictví název: tětiva číst FName;    konstruktor Vytvořit(Jméno: tětiva);  konec;konstruktor TPerson.Vytvořit(Jméno: tětiva);začít  FName := Jméno;konec;var  Osoba: TPerson;začít  Osoba := TPerson.Vytvořit('Petr'); // přidělí instanci TPerson a poté zavolá TPerson.Create s parametrem AName = 'Peter'konec.

Perl 5

v Programovací jazyk Perl verze 5, ve výchozím nastavení jsou konstruktory tovární metody, tj. metody, které vytvářejí a vracejí objekt, konkrétně to znamená vytvářet a vracet požehnaný odkaz. Typickým objektem je odkaz na hash, i když se zřídka používají i odkazy na jiné typy. Podle konvence je pojmenován jediný konstruktor Nový, i když je povoleno jej pojmenovat jinak nebo mít více konstruktorů. Například Person třída může mít konstruktor s názvem Nový stejně jako konstruktér new_from_file který čte soubor pro atributy osoby a new_from_person který jako šablonu používá jiný objekt Person.

balík Osoba;# V Perlu jsou konstruktéři konvence pojmenováni „noví“.sub Nový {    # Název třídy je implicitně předán jako 0. argument.    můj $ třída = posun;    # Výchozí hodnoty atributů, pokud nějaké máte.    můj % výchozí hodnoty = ( foo => "bar" );    # Inicializujte atributy jako kombinaci výchozích hodnot a předaných argumentů.    můj $ já = { % výchozí hodnoty, @_ };    # Zkontrolujte požadované argumenty, invariant třídy, atd.    -li ( ne definovaný $ já->{jméno} ) {        zemřít "Povinný atribut chybí v Person-> new (): first_name";    }    -li ( ne definovaný $ já->{příjmení} ) {        zemřít "Povinný atribut chybí v Person-> new (): last_name";    }    -li ( definovaný $ já->{stáří} a $ já->{stáří} < 18 ) {        zemřít „Neplatná hodnota atributu v Person-> new (): age <18“;    }    # Perl dělá předmět náležejícím do třídy „požehnáním“.    žehnat $ já, $ třída;    vrátit se $ já;}1;

Perl 5 s Moose

S Moose objektový systém pro Perl může být většina tohoto standardního standardu vynechána, výchozí Nový je možné vytvořit atributy, lze je určit, stejně jako to, zda je lze nastavit, resetovat nebo jsou vyžadovány. Kromě toho lze do a. Zahrnout jakoukoli další funkcionalitu konstruktoru STAVĚT metoda, kterou konstruktor generovaný Moose zavolá, poté, co zkontroluje argumenty. A BUILDARGS lze zadat metodu pro zpracování argumentů konstruktoru, které nejsou ve formě hodnoty hashref / key =>.

balík Osoba;# povolit konstrukci objektů ve stylu Moosepoužití Los;# křestní jméno (řetězec) lze nastavit pouze v době výstavby ('ro')má jméno => (je => 'ro', je => 'Str', Požadované => 1);# příjmení (řetězec) lze nastavit pouze v době výstavby ('ro')má příjmení  => (je => 'ro', je => 'Str', Požadované => 1);# age (Integer) lze po konstrukci upravit („rw“) a není to nutné# má být předán konstruktoru. Také vytvoří metodu 'has_age', která se vrátí# true, pokud byl nastaven věkmá stáří        => (je => 'rw', je => 'Int', predikát => 'has_age');# Zkontrolujte vlastní požadavkysub STAVĚT {      můj $ já = posun;      -li ($ já->has_age && $ já->stáří < 18) { # ne do 18 let           zemřít „Žádné osoby mladší 18 let“;      }}1;

V obou případech je třída Person vytvořena takto:

použití Osoba;můj $ str = Osoba->Nový( jméno => 'Sam', příjmení => 'Ashe', stáří => 42 );

Raku

S Raku, vzhledem k tomu, že je to výchozí, lze vynechat ještě více standardů Nový metoda je zděděna, lze specifikovat atributy a také to, zda je lze nastavit, resetovat nebo jsou vyžadovány. Kromě toho lze do a. Zahrnout jakoukoli další funkcionalitu konstruktoru STAVĚT metoda, která bude volána, aby umožnila vlastní inicializaci. A TWEAK lze specifikovat metodu pro následné zpracování jakýchkoli atributů již (implicitně) inicializovaných.

třída Osoba {    má Str $. první jméno je Požadované; # Jméno (řetězec) lze nastavit pouze na                                      # doba výstavby (. znamená „veřejné“).    má Str $ .poslední jméno je Požadované;  # Příjmení (řetězec) lze nastavit pouze na                                      # doba výstavby (a! by znamenalo „soukromé“).    má Int $. průměr je rw;              # Věk (celé číslo) lze upravit po                                       # construction ('rw'), a není vyžadováno                                      # během instance objektu.        # Vytvořte metodu 'celého jména', která vrátí celé jméno osoby.    # Tato metoda je přístupná mimo třídu.    metoda celé jméno { $! křestní jméno.tc ~ " " ~ $! příjmení.tc }    # Vytvořte metodu 'has-age', která vrátí true, pokud byl nastaven věk.    # Tato metoda se používá pouze uvnitř třídy, takže je deklarována jako „soukromá“    # doplněním názvu o!    metoda !má věk { já.stáří.definovaný }      # Zkontrolujte vlastní požadavky    metoda TWEAK {        -li já!má věk && $! věk < 18 { # Ne do 18 let            zemřít „Žádná osoba mladší 18 let“;        }    }}

Třída Person je vytvořena takto:

můj $ p0 = Osoba.Nový( jméno => 'Sam', příjmení => 'Ashe', stáří => 42 );můj $ p1 = Osoba.Nový( jméno => 'milost', příjmení => ‚násypka ' );říci $ p1.celé jméno(); # VÝSTUP: «Grace Hopper␤»

Alternativně lze pojmenované parametry zadat pomocí syntaxe dvojice dvojteček v Perlu 6:

můj $ p0 = Osoba.Nový( :jméno<Sam>, :příjmení<Ashe>, :stáří(42) );můj $ p1 = Osoba.Nový( :jméno<Grace>, :příjmení<Hopper> );

A pokud jste nastavili proměnné se jmény shodnými s pojmenovanými parametry, můžete použít zástupce, který bude používat název proměnné pro pojmenovaný parametr:

můj $ křestní jméno = "Sam";můj $ příjmení  = "Ashe";můj $ věk        = 42;můj $ p0 = Osoba.Nový( :$ křestní jméno, :$ příjmení, :$ věk );

PHP

v PHP verze 5 a vyšší, konstruktor je metoda s názvem __postavit() (všimněte si, že se jedná o dvojitý podtržítko), které klíčové slovo Nový automaticky zavolá po vytvoření objektu. Obvykle se používá k automatickému provádění inicializací, jako jsou inicializace vlastností. Konstruktory mohou také přijmout argumenty, v takovém případě, když Nový prohlášení je zapsáno, musíte také poslat argumenty konstruktoru pro parametry.^[1]

třída Osoba{    soukromé tětiva $ jméno;    veřejnost funkce __postavit(tětiva $ jméno): prázdnota    {        $ toto->název = $ jméno;    }    veřejnost funkce getName(): tětiva    {        vrátit se $ toto->název;    }}

Krajta

v Krajta, konstruktory jsou definovány jedním nebo oběma z __Nový__ a __init__ metody. Nová instance se vytvoří voláním třídy, jako by se jednalo o funkci, která volá __Nový__ a __init__ metody. Pokud metoda konstruktoru není ve třídě definována, další nalezená ve třídě Pořadí řešení metod bude volána.^[11]

V typickém případě pouze __init__ je třeba definovat metodu. (Nejběžnější výjimkou jsou neměnné objekty.)

>>> třída ExampleClass:...     def __Nový__(cls, hodnota):...         tisk("Vytváření nové instance ...")...         # Voláním konstruktoru nadtřídy vytvořte instanci....         instance = super(ExampleClass, cls).__Nový__(cls)...         vrátit se instance...     def __init__(já, hodnota):...         tisk("Inicializace instance ...")...         já.užitečné zatížení = hodnota>>> příkladInstance = ExampleClass(42)Vytváření nové instance ...Inicializuje se instance ...>>> tisk(příkladInstance.užitečné zatížení)42

Třídy obvykle fungují jako továrny pro nové instance samy o sobě, to znamená, že třída je volaný objekt (jako funkce), přičemž volání je konstruktor a volání třídy vrátí instanci této třídy. Nicméně __Nový__ metoda je povoleno vrátit něco jiného než instanci třídy pro specializované účely. V takovém případě __init__ není vyvolána.^[12]

Rubín

v Rubín, konstruktory jsou vytvořeny definováním metody zvané inicializovat. Tato metoda se provede k inicializaci každé nové instance.

irb (hlavní): 001: 0>třída ExampleClassirb (hlavní): 002: 1>  def inicializovatirb (hlavní): 003: 2>    uvádí "Ahoj"irb (hlavní): 004: 2>  konecirb (hlavní): 005: 1>konec=> nulairb (hlavní): 006: 0>ExampleClass.NovýAhoj=> # 

OCaml

v OCaml, existuje jeden konstruktor. Parametry jsou definovány hned za názvem třídy. Lze je použít k inicializaci proměnných instance a jsou přístupné v celé třídě. Anonymní skrytá metoda s názvem inicializátor umožňuje vyhodnotit výraz bezprostředně po vytvoření objektu.^[13]

třída osoba jméno příjmení =  objekt    val celé jméno = jméno ^ " " ^ příjmení    inicializátor      print_endline("Ahoj, já jsem" ^ celé jméno ^ ".")    metoda get_last_name = příjmení  konec;;nechat alonzo = Nový osoba "Alonzo" "Kostel" v (* Dobrý den, jsem Alonzo Church. *)print_endline alonzo#get_last_name (*Kostel*)

Viz také

• Místo přidělení
• Tvůrčí vzor
• Destruktor
• Globální konstruktor v C ++ a jeho protějšku C, ((konstruktor)) atribut funkce

Poznámky

Reference