Construtor (programação orientada a objetos) - Constructor (object-oriented programming)

Na programação orientada a objetos baseada em classes , um construtor (abreviação: ctor ) é um tipo especial de sub-rotina chamada para criar um objeto . Ele prepara o novo objeto para uso, geralmente aceitando argumentos que o construtor usa para definir as variáveis ​​de membro necessárias .

Um construtor se assemelha a um método de instância , mas difere de um método porque não tem tipo de retorno explícito , não é herdado implicitamente e geralmente tem regras diferentes para modificadores de escopo. Os construtores geralmente têm o mesmo nome da classe declarante . Eles têm a tarefa de inicializar os membros de dados do objeto e de estabelecer o invariante da classe , falhando se o invariante for inválido. Um construtor escrito corretamente deixa o objeto resultante em um estado válido . Objetos imutáveis devem ser inicializados em um construtor.

A maioria das linguagens permite sobrecarregar o construtor, pois pode haver mais de um construtor para uma classe, com parâmetros diferentes. Algumas linguagens levam em consideração alguns tipos especiais de construtores. Construtores, que concretamente usam uma única classe para criar objetos e retornar uma nova instância da classe, são abstraídos por fábricas , que também criam objetos, mas podem fazer isso de várias maneiras, usando várias classes ou diferentes esquemas de alocação, como um pool de objetos .

Tipos

Construtores parametrizados

Construtores que podem receber pelo menos um argumento são denominados construtores parametrizados. Quando um objeto é declarado em um construtor parametrizado, os valores iniciais devem ser passados ​​como argumentos para a função do construtor. A forma normal de declaração de objeto pode não funcionar. Os construtores podem ser chamados explicitamente ou implicitamente. O método de chamar o construtor implicitamente também é chamado de método abreviado. Se quisermos inicializar os campos da classe com seus próprios valores, use um construtor parametrizado.

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.

Construtores padrão

Se o programador não fornecer um construtor para uma classe instanciável, o compilador Java insere um construtor padrão em seu código em seu nome. Este construtor é conhecido como construtor padrão. Você não o encontraria em seu código-fonte (o arquivo java), pois seria inserido no código durante a compilação e existe no arquivo .class. O comportamento do construtor padrão depende do idioma. Ele pode inicializar membros de dados com zero ou outros mesmos valores, ou pode não fazer nada. Em Java, um "construtor padrão" refere-se a um construtor nulo que é gerado automaticamente pelo compilador se nenhum construtor tiver sido definido para a classe ou na ausência de qualquer construtor definido pelo programador (por exemplo, em Java, o construtor padrão chama implicitamente o construtor nulo da superclasse e, em seguida, executa um corpo vazio). Todos os campos são deixados com seu valor inicial de 0 (tipos inteiros), 0,0 (tipos de ponto flutuante), falso (tipo booleano) ou nulo (tipos de referência).

#include <iostream>

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

  int a;
  int b;
};

Construtores de cópia

Como C ++, Java também oferece suporte a "Copiar Construtor". Mas, ao contrário do C ++, Java não cria um construtor de cópia padrão se você não escrever o seu próprio. Os construtores de cópia definem as ações executadas pelo compilador ao copiar objetos de classe. Um construtor Copy tem um parâmetro formal que é o tipo da classe (o parâmetro pode ser uma referência a um objeto). É usado para criar uma cópia de um objeto existente da mesma classe. Mesmo que ambas as classes sejam iguais, ela conta como um construtor de conversão. Embora os construtores de cópia sejam geralmente abreviados para copy ctor ou cctor, eles não têm nada a ver com os construtores de classes usados ​​no .NET que usam a mesma abreviatura.

Construtores de conversão

Os construtores de conversão fornecem um meio para um compilador criar implicitamente um objeto pertencente a uma classe com base em um objeto de um tipo diferente. Esses construtores geralmente são chamados implicitamente para converter argumentos ou operandos em um tipo apropriado, mas também podem ser chamados explicitamente.

Mover construtores

Em C ++, os construtores de movimento tomam uma referência de valor a um objeto da classe e são usados ​​para implementar a transferência de propriedade dos recursos do objeto de parâmetro.

Sintaxe

• Java , C ++ , C # , ActionScript , PHP 4 e MATLAB têm uma convenção de nomenclatura na qual os construtores têm o mesmo nome da classe à qual estão associados.
• No PHP 5, um nome recomendado para um construtor é __construct. Para compatibilidade com versões anteriores, um método com o mesmo nome da classe será chamado se o __constructmétodo não puder ser encontrado. Desde o PHP 5.3.3, isso funciona apenas para classes sem namespace.
• No PHP 7, você deve sempre nomear o construtor como __construct. Métodos com o mesmo nome da classe irão disparar um erro de nível E_DEPRECATED.
• Em Perl , os construtores são, por convenção, chamados de "novos" e precisam fazer uma boa quantidade de criação de objetos.
• No sistema de objetos Moose para Perl, os construtores (chamados de novos ) são criados automaticamente e estendidos especificando um método BUILD .
• No Visual Basic .NET , o construtor é denominado " New".
• Em Python , o construtor é dividido em dois métodos, " __new__" e " __init__". O __new__método é responsável por alocar memória para a instância, e recebe a classe como um argumento (convencionalmente chamado de " cls"). O __init__método (freqüentemente chamado de "inicializador") é passado a instância recém-criada como um argumento (convencionalmente chamado de " self").
• Os construtores Object Pascal são identificados pela palavra-chave " constructor" e podem ter nomes definidos pelo usuário (mas são geralmente chamados de " Create").
• Em Objective-C , o método do construtor é dividido em dois métodos, " alloc" e " init" com o allocmétodo separando (alocando) memória para uma instância da classe e o initmétodo que trata da maior parte da inicialização da instância. Uma chamada para o método " new" invoca allocos initmétodos e os , para a instância da classe.

Organização da memória

Em Java, C # e VB .NET, o construtor cria objetos de tipo de referência em uma estrutura de memória especial chamada " heap ". Os tipos de valor (como int, double, etc.) são criados em uma estrutura sequencial chamada " pilha ". VB .NET e C # também permitem o uso do novo operador para criar objetos de tipo de valor, mas esses objetos de tipo de valor são criados na pilha, independentemente de o operador ser usado ou não.

Em C ++, os objetos são criados na pilha quando o construtor é chamado sem o operador new e criados no heap quando o construtor é chamado com o operador new. Os objetos de pilha são excluídos implicitamente quando saem do escopo, enquanto os objetos de pilha devem ser excluídos implicitamente por um destruidor ou explicitamente usando o operador delete .

Detalhes da linguagem

C ++

Em C ++ , o nome do construtor é o nome da classe. Não retorna nada. Ele pode ter parâmetros como qualquer função de membro . As funções do construtor são geralmente declaradas na seção pública, mas também podem ser declaradas nas seções protegidas e privadas, se o usuário quiser restringir o acesso a elas.

O construtor tem duas partes. A primeira é a lista de inicializadores que segue a lista de parâmetros e antes do corpo do método. Ele começa com dois pontos e as entradas são separadas por vírgulas. A lista de inicializadores não é necessária, mas oferece a oportunidade de fornecer valores para membros de dados e evitar instruções de atribuição separadas. A lista de inicializadores é necessária se você tiver membros de dados do tipo const ou de referência ou membros que não tenham lógica de construtor sem parâmetros. As atribuições ocorrem de acordo com a ordem em que os membros de dados são declarados (mesmo se a ordem na lista de inicializadores for diferente). A segunda parte é o corpo, que é um corpo de método normal entre chaves.

C ++ permite mais de um construtor. Os outros construtores devem ter parâmetros diferentes. Além disso, os construtores que contêm parâmetros aos quais são fornecidos valores padrão devem obedecer à restrição de que nem todos os parâmetros recebem um valor padrão. Esta é uma situação que só importa se houver um construtor padrão. O construtor de uma classe base (ou classes base) também pode ser chamado por uma classe derivada. As funções do construtor não são herdadas e seus endereços não podem ser referenciados. Quando a alocação de memória é necessária, os operadores new e delete são chamados implicitamente.

Um construtor de cópia tem um parâmetro do mesmo tipo passado como referência const , por exemplo Vector (const Vector & rhs) . Se não for fornecido explicitamente, o compilador usa o construtor de cópia para cada variável de membro ou simplesmente copia os valores no caso de tipos primitivos. A implementação padrão não é eficiente se a classe tem membros alocados dinamicamente (ou manipula outros recursos), porque pode levar a chamadas duplas para exclusão (ou liberação dupla de recursos) após a destruição.

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_;
};

Exemplo de invocações:

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

Ao retornar objetos de funções ou passar objetos por valor, o construtor de cópia de objetos será chamado implicitamente, a menos que a otimização do valor de retorno se aplique.

C ++ gera implicitamente um construtor de cópia padrão que chamará os construtores de cópia para todas as classes base e todas as variáveis ​​de membro, a menos que o programador forneça um, exclui explicitamente o construtor de cópia (para evitar a clonagem) ou uma das classes base ou variáveis ​​de membro construtor de cópia é excluída ou não acessível (privado). A maioria dos casos que exigem um construtor de cópia personalizado (por exemplo , contagem de referência , cópia profunda de ponteiros) também exige a personalização do destruidor e do operador de atribuição de cópia . Isso é comumente referido como a Regra de três .

C #

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

Construtor estático C #

Em C # , um construtor estático é um inicializador de dados estáticos. Construtores estáticos também são chamados de construtores de classe . Como o método real gerado tem o nome .cctor, eles também são chamados de "cctors".

Os construtores estáticos permitem a inicialização de variáveis ​​estáticas complexas. Construtores estáticos são chamados implicitamente quando a classe é acessada pela primeira vez. Qualquer chamada a uma classe (chamada estática ou construtor), dispara a execução do construtor estático. Construtores estáticos são thread-safe e implementam um padrão singleton . Quando usados ​​em uma classe de programação genérica , os construtores estáticos são chamados a cada nova instanciação genérica, um por tipo. Variáveis ​​estáticas também são instanciadas.

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 usa um método denominado ' init' como um método construtor.

Cheese.cfc

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

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

Crie uma instância de um queijo.

myCheese = new Cheese( 'Cheddar' );

Desde o ColdFusion 10, o CFML também oferece suporte à especificação do nome do método do construtor:

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

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

Eiffel

Em Eiffel , as rotinas que inicializam novos objetos são chamadas de procedimentos de criação . Os procedimentos de criação têm as seguintes características:

• Os procedimentos de criação não têm um tipo de retorno explícito (por definição de procedimento ).
• Os procedimentos de criação são nomeados.
• Os procedimentos de criação são designados pelo nome como procedimentos de criação no texto da classe.
• Os procedimentos de criação podem ser chamados explicitamente para reinicializar objetos existentes.
• Cada classe efetiva (isto é, concreta ou não abstrata) deve designar pelo menos um procedimento de criação.
• Os procedimentos de criação devem deixar o objeto recém-inicializado em um estado que satisfaça a invariante da classe.

Embora a criação de objetos envolva algumas sutilezas, a criação de um atributo com uma declaração típica x: Texpressa em uma instrução de criação create x.makeconsiste na seguinte sequência de etapas:

• Crie uma nova instância direta do tipo T.
• Execute o procedimento de criação makepara a instância recém-criada.
• Anexe o objeto recém-inicializado à entidade x.

No primeiro fragmento abaixo, a classe POINTé definida. O procedimento makeé codificado após a palavra-chave feature.

A palavra-chave createapresenta uma lista de procedimentos que podem ser usados ​​para inicializar instâncias. Nesse caso, a lista inclui default_createum procedimento com uma implementação vazia herdada da classe ANYe o makeprocedimento codificado na classe.

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
        ...

No segundo trecho, uma classe que é um cliente POINTtem declarações my_point_1e my_point_2do tipo POINT.

No código procedural, my_point_1é criado como a origem (0,0, 0,0). Como nenhum procedimento de criação é especificado, o procedimento default_createherdado da classe ANYé usado. Esta linha pode ter sido codificada create my_point_1.default_create. Apenas procedimentos nomeados como procedimentos de criação podem ser usados ​​em uma instrução com a createpalavra - chave. A seguir está uma instrução de criação para my_point_2, fornecendo valores iniciais para as my_point_2coordenadas de. A terceira instrução faz uma chamada de instância comum para o makeprocedimento para reinicializar a instância anexada my_point_2com valores diferentes.

    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 #

Em F # , um construtor pode incluir qualquer letou doinstruções definidas em uma classe. letas instruções definem campos privados e as doinstruções executam o código. Construtores adicionais podem ser definidos usando a newpalavra - chave.

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

Em Java , os construtores diferem de outros métodos porque:

• Os construtores nunca têm um tipo de retorno explícito.
• Construtores não podem ser chamados diretamente (a palavra-chave “ new” os chama).
• Os construtores não devem ter modificadores de não acesso.

Os construtores Java realizam as seguintes tarefas na seguinte ordem:

1. Chame o construtor padrão da superclasse se nenhum construtor estiver definido.
2. Inicialize as variáveis ​​de membro com os valores especificados.
3. Executa o corpo do construtor.

Java permite que os usuários chamem um construtor em outro construtor usando uma this()palavra-chave. Mas this()deve ser a primeira declaração.

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 fornece acesso ao construtor da superclasse por meio da superpalavra - chave.

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);

Um construtor com número zero de argumentos é chamado de construtor "sem argumentos" ou "sem argumentos".

JavaScript

A partir do ES6, o JavaScript tem construtores diretos como muitas outras linguagens de programação. Eles são escritos como tal

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

Isso pode ser instanciado como tal

const foo = new FooBar('7')

O equivalente a isso antes do ES6, era criar uma função que instancia um objeto como tal

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

Isso é instanciado da mesma maneira que acima.

Object Pascal

Em Object Pascal , o construtor é semelhante a um método de fábrica . A única diferença sintática para métodos regulares é a palavra-chave constructorna frente do nome (em vez de procedureou function). Ele pode ter qualquer nome, embora a convenção seja ter Createcomo prefixo, como em CreateWithFormatting. Criando uma instância de uma classe funciona como chamar um método estático de uma classe: 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

No OCaml , existe um construtor. Os parâmetros são definidos logo após o nome da classe. Eles podem ser usados ​​para inicializar variáveis ​​de instância e são acessíveis em toda a classe. Um método oculto anônimo chamado initializerpermite avaliar uma expressão imediatamente após o objeto ter sido construído.

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

No PHP versão 5 e superior, o construtor é um método denominado __construct()(observe que é um sublinhado duplo), que a palavra-chave newchama automaticamente após a criação do objeto. Geralmente é usado para executar inicializações automaticamente, como inicializações de propriedades. Os construtores também podem aceitar argumentos; nesse caso, quando a newinstrução é escrita, você também precisa enviar os argumentos do construtor para os parâmetros.

class Person
{
    private string $name;

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

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

Perl 5

Na linguagem de programação Perl versão 5, por padrão, os construtores são métodos de fábrica , ou seja, métodos que criam e retornam o objeto, significando concretamente criar e retornar uma referência abençoada. Um objeto típico é uma referência a um hash, embora raramente sejam usadas também referências a outros tipos. Por convenção, o único construtor é denominado novo , embora seja permitido nomeá-lo de outra forma ou ter vários construtores. Por exemplo, uma classe Person pode ter um construtor denominado new , bem como um construtor new_from_file que lê um arquivo para atributos Person, e new_from_person que usa outro objeto Person como modelo.

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 5 com Moose

Com o sistema de objetos Moose para Perl, a maior parte desse clichê pode ser omitido, um novo padrão é criado, os atributos podem ser especificados, bem como se eles podem ser definidos, redefinidos ou são obrigatórios. Além disso, qualquer funcionalidade extra do construtor pode ser incluída em um método BUILD que o construtor gerado pelo Moose chamará, depois de verificar os argumentos. Um método BUILDARGS pode ser especificado para lidar com os argumentos do construtor que não estão no formato hashref / chave => valor.

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;

Em ambos os casos, a classe Person é instanciada assim:

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

Pitão

Em Python , os construtores são definidos por um ou ambos os métodos __new__e __init__. Uma nova instância é criada chamando a classe como se fosse uma função, que chama os métodos __new__e __init__. Se um método construtor não for definido na classe, o próximo encontrado na Ordem de Resolução de Método da classe será chamado.

No caso típico, apenas o __init__método precisa ser definido. (A exceção mais comum é para objetos imutáveis.)

>>> 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

As classes normalmente agem como fábricas para novas instâncias delas mesmas, ou seja, uma classe é um objeto que pode ser chamado (como uma função), com a chamada sendo o construtor, e chamar a classe retorna uma instância dessa classe. No entanto, o __new__método tem permissão para retornar algo diferente de uma instância da classe para fins especializados. Nesse caso, o __init__não é invocado.

Raku

Com Raku , ainda mais clichês podem ser deixados de fora, uma vez que um novo método padrão é herdado, atributos podem ser especificados, bem como se eles podem ser definidos, redefinidos ou são obrigatórios. Além disso, qualquer funcionalidade extra do construtor pode ser incluída em um método BUILD que será chamado para permitir a inicialização personalizada. Um método TWEAK pode ser especificado para pós-processar quaisquer atributos já (implicitamente) inicializados.

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";
        }
    }
}

A classe Person é instanciada assim:

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␤»

Como alternativa, os parâmetros nomeados podem ser especificados usando a sintaxe de pares de dois pontos em Perl 6:

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

E se você tiver configurado variáveis ​​com nomes idênticos aos parâmetros nomeados, você pode usar um atalho que usará o nome da variável para o parâmetro nomeado:

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

Rubi

Em Ruby , os construtores são criados definindo um método chamado initialize. Este método é executado para inicializar cada nova instância.

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

No Visual Basic .NET , os construtores usam uma declaração de método com o nome " 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")

Veja também

• RAII
• Local de alocação
• Padrão de criação
• Destruidor
• Construtor global em C ++ e sua contraparte em C, atributo de função ((construtor))

Notas

Referências