En la programación orientada a objetos y basada en clases , un constructor (abreviatura: ctor ) es un tipo especial de función que se llama para crear un objeto . Prepara el nuevo objeto para su uso y, a menudo, acepta argumentos que el constructor utiliza para establecer las variables miembro requeridas .
Un constructor se parece a un método de instancia , pero se diferencia de un método en que no tiene un tipo de retorno explícito , no se hereda implícitamente y, por lo general, tiene reglas diferentes para los modificadores de alcance. Los constructores a menudo tienen el mismo nombre que la clase declarante . Tienen la tarea de inicializar los miembros de datos del objeto y de establecer el invariante de la clase , fallando si el invariante no es válido. Un constructor escrito correctamente deja el objeto resultante en un estado válido . Los objetos inmutables deben inicializarse en un constructor.
La mayoría de los lenguajes permiten sobrecargar el constructor, de modo que puede haber más de un constructor para una clase, con diferentes parámetros. Algunos lenguajes tienen en cuenta algunos tipos especiales de constructores. Los constructores, que utilizan concretamente una sola clase para crear objetos y devolver una nueva instancia de la clase, son abstraídos por fábricas , que también crean objetos pero pueden hacerlo de varias maneras, utilizando múltiples clases o diferentes esquemas de asignación, como un grupo de objetos .
Los constructores que pueden aceptar al menos un argumento se denominan constructores parametrizados. Cuando se declara un objeto en un constructor parametrizado, los valores iniciales deben pasarse como argumentos a la función constructora. La forma normal de declaración de objetos puede no funcionar. Los constructores pueden llamarse de forma explícita o implícita. El método de llamar al constructor de forma implícita también se denomina método abreviado.
clase Ejemplo { público : Ejemplo (); Ejemplo ( int a , int b ); // Constructor parametrizado. privado : int x_ ; int y_ ; }; Ejemplo :: Ejemplo () = predeterminado ; Ejemplo :: Ejemplo ( int x , int y ) : x_ ( x ), y_ ( y ) {} Ejemplo e = Ejemplo ( 0 , 50 ); // Llamada explícita. Ejemplo e2 ( 0 , 50 ); // Llamada implícita. Si el programador no proporciona un constructor para una clase instanciable, el compilador de Java inserta un constructor predeterminado en su código en su nombre. Este constructor se conoce como constructor predeterminado. No lo encontrará en su código fuente (el archivo java) ya que se insertaría en el código durante la compilación y existe en el archivo .class. El comportamiento del constructor predeterminado depende del lenguaje. Puede inicializar los miembros de datos a cero u otros valores iguales, o puede no hacer nada en absoluto. En Java, un "constructor predeterminado" se refiere a un constructor nulo que genera automáticamente el compilador si no se han definido constructores para la clase o en ausencia de constructores definidos por el programador (por ejemplo, en Java, el constructor predeterminado llama implícitamente al constructor nulo de la superclase y luego ejecuta un cuerpo vacío). Todos los campos se dejan en su valor inicial de 0 (tipos enteros), 0.0 (tipos de punto flotante), falso (tipo booleano) o nulo (tipos de referencia)...
#include <flujo de datos> clase Estudiante { public : Estudiante ( int a = 0 , int b = 0 ); // Constructor predeterminado. entero a ; entero b ; }; Al igual que C++, Java también admite el "constructor de copia". Pero, a diferencia de C++, Java no crea un constructor de copia predeterminado si no escribe el suyo propio. Los constructores de copia definen las acciones que realiza el compilador al copiar objetos de clase. Un constructor de copia tiene un parámetro formal que es el tipo de la clase (el parámetro puede ser una referencia a un objeto). Se utiliza para crear una copia de un objeto existente de la misma clase. Aunque ambas clases son iguales, cuenta como un constructor de conversión. Si bien los constructores de copia generalmente se abrevian como copy ctor o cctor, no tienen nada que ver con los constructores de clase utilizados en .NET que utilizan la misma abreviatura.
Los constructores de conversión proporcionan un medio para que un compilador cree implícitamente un objeto perteneciente a una clase en función de un objeto de un tipo diferente. Estos constructores suelen invocarse de forma implícita para convertir argumentos u operandos a un tipo adecuado, pero también pueden invocarse de forma explícita.
En C++, los constructores de movimiento toman una referencia Rvalue a un objeto de la clase y se utilizan para implementar la transferencia de propiedad de los recursos del objeto de parámetro.
__construct. Para compatibilidad con versiones anteriores, se llamará a un método con el mismo nombre que la clase si __constructno se puede encontrar el método. Desde PHP 5.3.3, esto funciona solo para clases sin espacios de nombres. [1]__construct. Los métodos con el mismo nombre que la clase generarán un error de nivel E_DEPRECATED. [1]New".__new__" y " __init__". El __new__método es responsable de asignar memoria para la instancia y recibe la clase como argumento (convencionalmente llamado " cls"). El __init__método (a menudo llamado "el inicializador") recibe la instancia recién creada como argumento (convencionalmente llamado " self"). [2]constructor" y pueden tener nombres definidos por el usuario (pero en su mayoría se denominan " Create").alloc" y " init", con el allocmétodo reservando (asignando) memoria para una instancia de la clase, y el initmétodo manejando la mayor parte de la inicialización de la instancia. Una llamada al método " new" invoca tanto el método alloccomo el initmétodo para la instancia de la clase.En Java, C# y VB .NET, el constructor crea objetos de tipo de referencia en una estructura de memoria especial llamada " heap ". Los tipos de valor (como int, double, etc.) se crean en una estructura secuencial llamada " stack ". VB .NET y C# también permiten el uso del operador new para crear objetos de tipo de valor, pero estos objetos de tipo de valor se crean en la pila independientemente de si se utiliza el operador o no.
En C++, los objetos se crean en la pila cuando se invoca el constructor sin el operador new, y se crean en el montón cuando se invoca el constructor con el operador new. Los objetos de la pila se eliminan de forma implícita cuando quedan fuera del ámbito, mientras que los objetos del montón deben eliminarse de forma implícita mediante un destructor o de forma explícita mediante el operador delete .
Los constructores se implementan en diferentes lenguajes de programación de diversas maneras, entre ellas:
En C++ , el nombre del constructor es el nombre de la clase. No devuelve nada. Puede tener parámetros como cualquier función miembro . Las funciones constructoras suelen declararse en la sección pública, pero también pueden declararse en las secciones protegida y privada, si el usuario desea restringir el acceso a ellas.
El constructor tiene dos partes. La primera es la lista de inicializadores que sigue a la lista de parámetros y antes del cuerpo del método. Comienza con dos puntos y las entradas están separadas por comas. La lista de inicializadores no es obligatoria, pero ofrece la oportunidad de proporcionar valores para los miembros de datos y evitar declaraciones de asignación separadas. La lista de inicializadores es obligatoria si tiene miembros de datos de tipo constante o de referencia, o miembros que no tienen lógica de constructor sin parámetros. Las asignaciones se producen de acuerdo con el orden en el que se declaran los miembros de datos (incluso si el orden en la lista de inicializadores es diferente). [3] La segunda parte es el cuerpo, que es un cuerpo de método normal entre llaves.
C++ permite más de un constructor. Los demás constructores deben tener parámetros diferentes. Además, los constructores que contienen parámetros a los que se les asignan valores predeterminados deben cumplir con la restricción de que no todos los parámetros reciben un valor predeterminado. Esta es una situación que solo importa si existe un constructor predeterminado. El constructor de una clase base (o clases base) también puede ser llamado por una clase derivada. Las funciones constructoras no se heredan y no se puede hacer referencia a sus direcciones. Cuando se requiere la asignación de memoria, los operadores new y delete se llaman implícitamente.
Un constructor de copia tiene un parámetro del mismo tipo que se pasa como referencia constante , por ejemplo, Vector(const Vector& rhs) . Si no se proporciona explícitamente, el compilador utiliza el constructor de copia para cada variable miembro o simplemente copia los valores en el caso de tipos primitivos. La implementación predeterminada no es eficiente si la clase ha asignado miembros dinámicamente (o identificadores para otros recursos), porque puede provocar llamadas dobles para eliminar (o liberación doble de recursos) en caso de destrucción.
clase Foobar { public : Foobar ( double r = 1.0 , double alpha = 0.0 ) // Constructor, parámetros con valores predeterminados. : x_ ( r * cos ( alpha )) // <- Lista de inicializadores { y_ = r * sin ( alpha ); // <- Asignación normal } privado : doble x_ ; doble y_ ; }; Ejemplos de invocaciones:
Foobar a , b ( 3 ), c ( 5 , M_PI / 4 ); Al devolver objetos desde funciones o pasar objetos por valor, se llamará implícitamente al constructor de copia de objetos, a menos que se aplique la optimización del valor de retorno .
C++ genera implícitamente un constructor de copia predeterminado que llamará a los constructores de copia para todas las clases base y todas las variables miembro a menos que el programador proporcione uno, elimine explícitamente el constructor de copia (para evitar la clonación) o uno de los constructores de copia de las clases base o variables miembro se elimine o no sea accesible (privado). La mayoría de los casos que requieren un constructor de copia personalizado (por ejemplo, recuento de referencias , copia profunda de punteros) también requieren personalizar el destructor y el operador de asignación de copia . Esto se conoce comúnmente como la Regla de tres .
Ejemplo de constructor de C# :
clase pública MiClase { int privado a ; cadena privada b ; // Constructor público MyClass () : this ( 42 , "cadena" ) { } // Sobrecarga de un constructor public MyClass ( int a , string b ) { this . a = a ; this . b = b ; } } // Código en algún lugar // Instanciar un objeto con el constructor anterior MyClass c = new MyClass ( 42 , "string" ); En C# , un constructor estático es un inicializador de datos estático. [4] : 111–112 Los constructores estáticos también se denominan constructores de clase . Dado que el método real generado tiene el nombre .cctor, a menudo también se los denomina "cctors". [5] [6]
Los constructores estáticos permiten la inicialización compleja de variables estáticas. [7] Los constructores estáticos se llaman implícitamente cuando se accede a la clase por primera vez. Cualquier llamada a una clase (estática o llamada al constructor), activa la ejecución del constructor estático. Los constructores estáticos son seguros para subprocesos e implementan un patrón singleton . Cuando se usan en una clase de programación genérica , los constructores estáticos se llaman en cada nueva instancia genérica, uno por tipo. [8] : 38 [4] : 111 Las variables estáticas también se instancian.
clase pública MiClase { privada estática int _A ; // Constructor normal static MyClass () { _A = 32 ; } // Constructor predeterminado estándar public MyClass () { } }// Código en algún lugar // Instanciar un objeto con el constructor anterior // justo antes de la instanciación // Se ejecuta el constructor estático variable y _A es 32 MyClass c = new MyClass (); El lenguaje de marcado ColdFusion (CFML) utiliza un método llamado ' init' como método constructor.
Queso.cfc
componente { // propiedades nombre de la propiedad = "cheeseName" ; // función constructora Cheese init ( string requerido cheeseName ) { variables . cheeseName = argumentos . cheeseName ; devolver esto ; } } Crear instancia de un queso.
miQueso = nuevo Queso ( 'Cheddar' ); Desde ColdFusion 10, [9] CFML también admite la especificación del nombre del método constructor:
componente initmethod = "Cheese" { // propiedades nombre de la propiedad = "cheeseName" ; // función constructora Queso Queso ( cadena requerida cheeseName ) { variables . cheeseName = argumentos . cheeseName ; devolver esto ; } } En Eiffel , las rutinas que inicializan nuevos objetos se denominan procedimientos de creación . Los procedimientos de creación tienen las siguientes características:
Aunque la creación de objetos implica algunas sutilezas, [10] la creación de un atributo con una declaración típica x: Tcomo la expresada en una instrucción de creación create x.makeconsta de la siguiente secuencia de pasos:
T. [c]makeen la instancia recién creada.x.En el primer fragmento que aparece a continuación, POINTse define la clase. El procedimiento makese codifica después de la palabra clave feature.
La palabra clave createintroduce una lista de procedimientos que se pueden utilizar para inicializar instancias. En este caso, la lista incluye default_create, un procedimiento con una implementación vacía heredada de la clase ANYy el makeprocedimiento codificado dentro de la clase.
clase POINT crear default_create , hacer característica hacer ( a_x_valor : REAL ; a_y_valor : REAL ) hacer x := a_x_valor y := a_y_valor fin x : REAL -- Coordenada X y : REAL -- Coordenada Y ... En el segundo fragmento, una clase que es un cliente POINTtiene declaraciones my_point_1y my_point_2de tipo POINT.
En el código procedimental, my_point_1se crea como el origen (0.0, 0.0). Debido a que no se especifica ningún procedimiento de creación, se utiliza el procedimiento default_createheredado de la clase ANY. Esta línea podría haberse codificado como create my_point_1.default_create. Solo los procedimientos nombrados como procedimientos de creación se pueden utilizar en una instrucción con la createpalabra clave. A continuación, se incluye una instrucción de creación para my_point_2, que proporciona valores iniciales para las my_point_2coordenadas de . La tercera instrucción realiza una llamada de instancia ordinaria al makeprocedimiento para reinicializar la instancia adjunta a my_point_2con valores diferentes.
mi_punto_1 : PUNTO mi_punto_2 : PUNTO ... crear mi_punto_1 crear mi_punto_2 .make ( 3.0,4.0 ) mi_punto_2 .make ( 5.0,8.0 ) ... En F# , un constructor puede incluir cualquier instrucción leto dodefinida en una clase. letLas instrucciones definen campos privados y dolas instrucciones ejecutan código. Se pueden definir constructores adicionales utilizando la newpalabra clave.
tipo MyClass (_ a : int , _ b : string ) = clase // Constructor primario let a = _ a let b = _ b do printfn "a = %i, b = %s" a b // Constructores adicionales new (_ a : int ) = MyClass (_ a , "" ) then printfn "Parámetro entero dado" new (_ b : string ) = MyClass ( 0 , _ b ) entonces printfn "Parámetro de cadena proporcionado" new () = MyClass ( 0 , "" ) entonces printfn "No se proporcionó ningún parámetro" fin // Código en algún lugar // instanciando un objeto con el constructor principal let c1 = new MyClass ( 42 , "string" ) // instanciar un objeto con constructores adicionales let c2 = new MyClass ( 42 ) let c3 = new MyClass ( "string" ) let c4 = MyClass () // La palabra clave "new" es opcional En Java , los constructores se diferencian de otros métodos en que:
new” los invoca).Los constructores de Java realizan las siguientes tareas en el siguiente orden:
Java permite a los usuarios llamar a un constructor desde otro constructor mediante this()palabras clave, pero this()debe ser la primera instrucción. [11]
clase Ejemplo { Ejemplo () // Constructor no parametrizado { this ( 1 ); // Llamada del constructor System . out . println ( "0-arg-cons" ); } Ejemplo ( int a ) // Constructor parametrizado { System . out . println ( "1-arg-cons" ); } } public static void main ( String [] args ) { Ejemplo e = new Ejemplo (); } Java proporciona acceso al constructor de la superclasesuper a través de la palabra clave.
clase pública Ejemplo { // Definición del constructor. public Example () { this ( 1 ); } // Sobrecarga de un constructor public Example ( int input ) { data = input ; // Esto es una asignación } // Declaración de variable(s) de instancia. private int data ; } // Código en otro lugar // Instanciando un objeto con el constructor anterior Ejemplo e = new Ejemplo ( 42 ); Un constructor que toma un número cero de argumentos se denomina constructor "sin argumentos" o "sin argumentos". [12]
A partir de ES6, JavaScript tiene constructores directos como muchos otros lenguajes de programación. Están escritos como tales.
clase FooBar { constructor ( baz ) { this.baz = baz } } Esto se puede instanciar como tal
constante foo = nuevo FooBar ( '7' ) El equivalente de esto antes de ES6 era crear una función que instancia un objeto como tal.
función FooBar ( baz ) { this.baz = baz ; } Esto se instancia de la misma manera que arriba.
En Object Pascal , el constructor es similar a un método de fábrica . La única diferencia sintáctica con los métodos regulares es la palabra clave constructorque se encuentra delante del nombre (en lugar de procedureo function). Puede tener cualquier nombre, aunque la convención es tener Createcomo prefijo, como en CreateWithFormatting. Crear una instancia de una clase funciona como llamar a un método estático de una clase: TPerson.Create('Peter').
programa OopProgram ; tipo TPerson = clase privada FName : cadena ; propiedad pública Nombre : cadena leer FName ; constructor Create ( AName : cadena ) ; fin ; constructor TPerson . Create ( AName : string ) ; inicio FName := AName ; fin ; var Persona : TPerson ; begin Persona := TPerson . Create ( 'Peter' ) ; // asigna una instancia de TPerson y luego llama a TPerson.Create con el parámetro AName = 'Peter' end . En OCaml , hay un constructor. Los parámetros se definen justo después del nombre de la clase. Se pueden utilizar para inicializar variables de instancia y son accesibles en toda la clase. Un método oculto anónimo llamado initializerpermite evaluar una expresión inmediatamente después de que se haya creado el objeto. [13]
clase persona nombre apellido = objeto val nombre completo = nombre ^ " " ^ apellido inicializador print_endline ( "Hola, soy " ^ nombre_completo ^ "." ) método get_last_name = apellido fin ;;sea alonzo = nueva persona "Alonzo" "Iglesia" en (*Hola, soy Alonzo Church.*)print_endline alonzo # obtener_apellido (*Iglesia*)En la versión 5 de PHP y posteriores, el constructor es un método llamado __construct()(observe que es un guión bajo doble), al que la palabra clave newllama automáticamente después de crear el objeto. Por lo general, se utiliza para realizar inicializaciones automáticas, como inicializaciones de propiedades. Los constructores también pueden aceptar argumentos, en cuyo caso, cuando newse escribe la declaración, también debe enviar los argumentos del constructor para los parámetros. [1]
clase Persona { cadena privada $nombre ; función pública __construct ( cadena $nombre ) : void { $this -> nombre = $nombre ; } función pública getName () : cadena { return $this -> nombre ; } }En PHP, una clase solo puede declarar un máximo de un método constructor. Los métodos estáticos, las clases de fábrica o los argumentos constructores opcionales son algunas formas de facilitar múltiples formas de crear objetos de una clase PHP.
En la versión 5 de Perl , por defecto, los constructores son métodos de fábrica , es decir, métodos que crean y devuelven el objeto, es decir, crean y devuelven una referencia bendita. Un objeto típico es una referencia a un hash, aunque rara vez se utilizan también referencias a otros tipos. Por convención, el único constructor se llama new , aunque se permite darle otro nombre o tener varios constructores. Por ejemplo, una clase Person puede tener un constructor llamado new , y un constructor new_from_file que lee un archivo en busca de atributos Person, y new_from_person que utiliza otro objeto Person como plantilla.
paquete Persona ; # En Perl los constructores se llaman 'nuevos' por convención. sub new { # El nombre de la clase se pasa implícitamente como argumento 0. my $class = shift ; # Valores de atributos predeterminados, si tiene alguno. my %defaults = ( foo => "bar" ); # Inicializar atributos como una combinación de valores predeterminados y argumentos pasados. my $self = { %defaults , @_ }; # Verificar argumentos obligatorios, invariantes de clase, etc. if ( notdefined $self -> { first_name } ) { die "Falta atributo obligatorio en Person->new(): first_name" ; } if ( notdefined $self -> { last_name } ) { die " Falta atributo obligatorio en Person- > new ( ) : last_name " ; } if ( defined $ self - > { age } and $ self - > { age } < 18 ) { die " Valor de atributo no válido en Person->new(): age < 18" ; } # Perl hace que un objeto pertenezca a una clase mediante 'bless'. bless $self , $class ; return $self ; } 1 ; En el sistema de objetos Moose para Perl, se puede omitir la mayor parte de este código repetitivo, se crea un nuevo valor predeterminado, se pueden especificar atributos y si se pueden configurar, restablecer o son obligatorios. Además, cualquier funcionalidad adicional del constructor se puede incluir en un método BUILD que el constructor generado por Moose llamará después de haber comprobado los argumentos. Se puede especificar un método BUILDARGS para manejar argumentos del constructor que no estén en formato hashref / clave => valor.
paquete Persona ; # habilitar la construcción de objetos estilo Moose use Moose ; # el nombre (una cadena) solo se puede configurar en el momento de la construcción ('ro') has first_name => ( is => 'ro' , isa => 'Str' , required => 1 ); # el apellido (una cadena) solo se puede configurar en el momento de la construcción ('ro') has last_name => ( is => 'ro' , isa => 'Str' , required => 1 ); # la edad (entero) se puede modificar después de la construcción ('rw'), y no es necesario # que se pase al constructor. También crea un método 'has_age' que devuelve # verdadero si se ha configurado la edad has age => ( is => 'rw' , isa => 'Int' , predicate => 'has_age' ); # Verificar requisitos personalizados sub BUILD { my $self = shift ; if ( $self -> has_age && $self -> age < 18 ) { # no menores de 18 años die "No menores de 18 años" ; } } 1 ; En ambos casos la clase Persona se inicia de la siguiente manera:
usar Persona ; mi $p = Persona -> nuevo ( nombre => 'Sam' , apellido => 'Ashe' , edad => 42 ); En Python , los constructores se definen mediante uno o ambos métodos __new__y __init__. Se crea una nueva instancia llamando a la clase como si fuera una función, que llama a los métodos __new__y . Si no se define un método constructor en la clase, se llamará al siguiente que se encuentre en el orden de resolución de métodos__init__ de la clase . [14]
En el caso típico, solo __init__es necesario definir el método. (La excepción más común es para los objetos inmutables).
>>> class ExampleClass : ... def __new__ ( cls , value ): ... print ( "Creando nueva instancia..." ) ... # Llamar al constructor de la superclase para crear la instancia. ... instance = super ( ExampleClass , cls ) . __new__ ( cls ) ... return instance ... def __init__ ( self , value ): ... print ( "Inicializando instancia..." ) ... self . payload = value >>> exampleInstance = ExampleClass ( 42 ) Creando nueva instancia... Inicializando instancia... >>> print ( exampleInstance . payload ) 42Las clases normalmente actúan como fábricas para nuevas instancias de sí mismas, es decir, una clase es un objeto invocable (como una función), donde la llamada es el constructor y la llamada a la clase devuelve una instancia de esa clase. Sin embargo, __new__se permite que el método devuelva algo distinto a una instancia de la clase para fines especializados. En ese caso, __init__no se invoca. [15]
En Raku , se puede omitir incluso más código repetitivo, dado que se hereda un nuevo método predeterminado, se pueden especificar atributos y si se pueden configurar, restablecer o son obligatorios. Además, cualquier funcionalidad adicional del constructor se puede incluir en un método BUILD que se llamará para permitir la inicialización personalizada. Se puede especificar un método TWEAK para posprocesar cualquier atributo ya inicializado (implícitamente).
clase Persona { has Str $.first-name es obligatorio ; # El nombre (una cadena) solo se puede establecer en # el momento de la construcción (el . significa "público"). has Str $.last-name es obligatorio ; # El apellido (una cadena) solo se puede establecer en # el momento de la construcción (un ! significaría "privado"). has Int $.age es rw ; # La edad (un entero) se puede modificar después # de la construcción ('rw'), y no es obligatorio # durante la instanciación del objeto. # Crea un método 'full-name' que devuelve el nombre completo de la persona. # Se puede acceder a este método fuera de la clase. method full-name { $!first-name . tc ~ " " ~ $!last-name . tc } # Crea un método 'has-age' que devuelva verdadero si se ha establecido la edad. # Este método se usa solo dentro de la clase, por lo que se declara como "privado" # anteponiendo su nombre con un ! método ! has-age { self . age . definido } # Verificar el método de requisitos personalizados TWEAK { if self ! has-age && $!age < 18 { # No menores de 18 die "Ninguna persona menor de 18 años" ; } }}La clase Persona se instancia de la siguiente manera:
mi $p0 = Persona . new ( nombre-de-nombre => 'Sam' , apellido-de-nombre => 'Ashe' , edad => 42 ); mi $p1 = Persona . new ( nombre-de-nombre => 'grace' , apellido-de-nombre => 'hopper' ); digamos $p1 . nombre-completo (); # SALIDA: «Grace Hopper»Alternativamente, los parámetros nombrados se pueden especificar utilizando la sintaxis de par de dos puntos en Perl 6:
mi $p0 = Persona . new ( : nombre <Sam> , : apellido <Ashe> , : edad ( 42 ) ); mi $p1 = Persona . new ( : nombre <Grace> , : apellido <Hopper> );Y si ha configurado variables con nombres idénticos a los parámetros nombrados, puede utilizar un acceso directo que utilizará el nombre de la variable para el parámetro nombrado:
mi $nombre = "Sam" ; mi $apellido = "Ashe" ; mi $edad = 42 ; mi $p0 = Persona . new ( : $nombre , : $apellido , : $edad );En Ruby , los constructores se crean definiendo un método llamado initialize. Este método se ejecuta para inicializar cada nueva instancia.
irb(main):001:0> clase ExampleClass irb(main):002:1> def initialize irb(main):003:2> pone "Hola" irb(main):004:2> fin irb(main):005:1> fin => nil irb(main):006:0> ExampleClass . new Hola => #<ExampleClass:0x007fb3f4299118> En Visual Basic .NET , los constructores utilizan una declaración de método con el nombre " New".
Clase Foobar Private strData como cadena ' Constructor Public Sub New ( ByVal someParam As String ) strData = someParam Fin Sub Fin Clase ' código en otro lugar ' instanciando un objeto con el constructor anterior Dim foo As New Foobar ( ".NET" )