En la programación orientada a objetos basada en clases , un constructor (abreviatura: ctor ) es un tipo especial de función llamada 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 normalmente tiene reglas diferentes para los modificadores de alcance. Los constructores suelen tener 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 en el sentido de que puede haber más de un constructor para una clase, con diferentes parámetros. Algunos lenguajes toman en consideración 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, usando múltiples clases o diferentes esquemas de asignación, como un grupo de objetos .
Los constructores que pueden tomar 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. Es posible que la forma normal de declaración de objetos no funcione. Los constructores se pueden llamar explícita o implícitamente. El método de llamar implícitamente al constructor 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á en el código durante la compilación y existirá en el archivo .class. El comportamiento del constructor predeterminado depende del idioma. Puede inicializar 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 el compilador genera automáticamente 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, 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)...
#incluir <iostream> clase Estudiante { público : Estudiante ( int a = 0 , int b = 0 ); // Constructor predeterminado. en un ; intb ; }; Al igual que C++, Java también admite "Copy Constructor". Pero, a diferencia de C++, Java no crea un constructor de copia predeterminado si no escribes el tuyo propio. Los constructores de copia definen las acciones realizadas por el compilador al copiar objetos de clase. Un constructor de copia tiene un parámetro formal que es el tipo de 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 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 clases utilizados en .NET que usan la misma abreviatura.
Los constructores de conversión proporcionan un medio para que un compilador cree implícitamente un objeto que pertenece a una clase basándose en un objeto de un tipo diferente. Estos constructores normalmente se invocan implícitamente para convertir argumentos u operandos a un tipo apropiado, pero también se pueden llamar explícitamente.
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 sólo para clases sin espacios de nombres. [1]__construct. Los métodos con el mismo nombre que la clase desencadenará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"). Al __init__método (a menudo llamado "el inicializador") se le pasa 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 llaman " Create").alloc" y " init"; el allocmétodo reserva (asigna) memoria para una instancia de la clase y el initmétodo maneja la mayor parte de la inicialización de la instancia. Una llamada al método " new" invoca tanto el método alloccomo los initmétodos para la instancia de clase.En Java, C# y VB .NET, el constructor crea objetos de tipo de referencia en una estructura de memoria especial llamada " montón ". Los tipos de valor (como int, double, etc.) se crean en una estructura secuencial llamada " pila ". VB .NET y C# también permiten el uso del nuevo operador para crear objetos de tipo valor, pero estos objetos de tipo valor se crean en la pila independientemente de si se usa el operador o no.
En C++, los objetos se crean en la pila cuando se invoca el constructor sin el operador nuevo y se crean en el montón cuando se invoca el constructor con el operador nuevo. Los objetos de la pila se eliminan implícitamente cuando salen del alcance, mientras que los objetos del montón deben eliminarse implícitamente mediante un destructor o explícitamente mediante el uso del operador de eliminación .
Los constructores se implementan en diferentes lenguajes de programación de varias maneras, incluyendo:
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 del constructor generalmente se declaran en la sección pública, pero también se pueden declarar en las secciones protegida y privada, si el usuario desea restringir el acceso a ellas.
El constructor tiene dos partes. Primero está 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 necesaria 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 según el orden en 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 encerrado entre llaves.
C++ permite más de un constructor. Los otros 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 sólo importa si hay un constructor predeterminado. El constructor de una clase base (o clases base) también puede ser llamado por una clase derivada. Las funciones del constructor no se heredan y no se puede hacer referencia a sus direcciones. Cuando se requiere asignación de memoria, los operadores nuevo y de eliminación se llaman implícitamente.
Un constructor de copia tiene un parámetro del mismo tipo pasado 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 valores en el caso de tipos primitivos. La implementación predeterminada no es eficiente si la clase ha asignado miembros dinámicamente (o identificadores de otros recursos), porque puede generar llamadas dobles para eliminar (o liberación doble de recursos) tras la destrucción.
class 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_ ; }; Invocaciones de ejemplo:
Foobar a , b ( 3 ), c ( 5 , M_PI / 4 ); Al devolver objetos de 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 se elimine una de las clases base o variables miembro. o no 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 { privado int a ; cadena privada b ; // Constructor público MiClase () : this ( 42 , "cadena" ) { } // Sobrecargando un constructor public MyClass ( int a , string b ) { this . una = una ; este . b = b ; } } // Codificar en alguna parte // Crear una instancia de un objeto con el constructor anterior MyClass c = new MyClass ( 42 , "string" ); En C# , un constructor estático es un inicializador de datos estáticos. [4] : 111–112 Los constructores estáticos también se denominan constructores de clases . Dado que el método real generado tiene el nombre .cctor, a menudo también se les llama "cctors". [5] [6]
Los constructores estáticos permiten la inicialización de variables estáticas complejas. [7] Los constructores estáticos se llaman implícitamente cuando se accede a la clase por primera vez. Cualquier llamada a una clase (llamada estática o de constructor) desencadena la ejecución del constructor estático. Los constructores estáticos son seguros para subprocesos e implementan un patrón singleton . Cuando se utilizan en una clase de programación genérica , los constructores estáticos se llaman en cada nueva instanciación genérica, uno por tipo. [8] : 38 [4] : 111 También se crean instancias de variables estáticas.
clase pública MiClase { privado estático int _A ; // Constructor normal estático MiClase () { _A = 32 ; } // Constructor estándar predeterminado public MyClass () { } }// Código en alguna parte // Creación de instancias de un objeto con el constructor de arriba // justo antes de la creación de instancias // Se ejecuta el constructor estático variable y _A es 32 MyClass c = new MyClass (); ColdFusion Markup Language (CFML) utiliza un método denominado " init" como método constructor.
Queso.cfc
componente { // propiedades nombre de propiedad = "nombre del queso" ; // función constructora Cheese init ( cadena requerida nombre del queso ) { variables . nombreDeQueso = argumentos . nombre del queso ; devolver esto ; } } Crea una instancia de un queso.
myCheese = queso nuevo ( 'Cheddar' ); Desde ColdFusion 10, [9] CFML también admite especificar el nombre del método constructor:
componente initmethod = "Queso" { // propiedades nombre de propiedad = "nombre del queso" ; // función constructora Queso Queso ( cadena requerida nombreQueso ) { variables . nombreDeQueso = argumentos . nombre del queso ; 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: Texpresada en una instrucción de creación create x.makeconsta de la siguiente secuencia de pasos:
T. [C]makede la instancia recién creada.x.En el primer fragmento a continuación, POINTse define la clase. El procedimiento makeestá codificado 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_createun procedimiento con una implementación vacía heredada de la clase ANYy el makeprocedimiento codificado dentro de la clase.
clase PUNTO crear default_create , hacer característica hacer ( a_x_value : REAL ; a_y_value : REAL ) hacer x : = a_x_value y : = a_y_value fin x : REAL -- Coordenada X y : REAL -- Coordenada Y ... En el segundo fragmento, una clase que es cliente POINTtiene declaraciones my_point_1y my_point_2de tipo POINT.
En el código de procedimiento, my_point_1se crea como origen (0.0, 0.0). Como no se especifica ningún procedimiento de creación, se utiliza el procedimiento default_createheredado de la clase . ANYEsta línea podría haber sido codificada create my_point_1.default_create. Sólo los procedimientos nombrados como procedimientos de creación se pueden utilizar en una instrucción con la createpalabra clave. La siguiente es 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 my_point_2con valores diferentes.
mi_punto_1 : PUNTO mi_punto_2 : PUNTO ... crear mi_punto_1 crear mi_punto_2 . hacer ( 3.0 , 4.0 ) mi_punto_2 . hacer ( 5.0 , 8.0 ) ... En F# , un constructor puede incluir cualquiera de las declaraciones leto dodefinidas en una clase. letLas declaraciones definen campos privados y dolas declaraciones ejecutan código. Se pueden definir constructores adicionales utilizando la newpalabra clave.
escriba MiClase (_ 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 , "" ) luego printfn "Parámetro entero dado" new (_ b : string ) = MyClass ( 0 , _ b ) luego printfn "Parámetro de cadena dado" new () = MyClass ( 0 , "" ) luego printfn "No se proporciona ningún parámetro" final // Codificar en alguna parte // crear instancias de un objeto con el constructor primario let c1 = new MyClass ( 42 , "string" ) // crear instancias de 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 en otro constructor usando this()una palabra clave. Pero this()debe ser la primera declaración. [11]
clase Ejemplo { Ejemplo () // Constructor no parametrizado { this ( 1 ); // Llamada del constructor System . afuera . println ( "0-arg-cons" ); } Ejemplo ( int a ) // Constructor parametrizado { System . afuera . println ( "1-arg-contras" ); } } public static void main ( String [] args ) { Ejemplo e = nuevo Ejemplo (); } Java proporciona acceso al constructor de la superclasesuper a través de la palabra clave.
public class Ejemplo { // Definición del constructor. Ejemplo público () { this ( 1 ); } // Sobrecarga de un constructor public Ejemplo ( int entrada ) { datos = entrada ; // Esta es una tarea } // Declaración de variable(s) de instancia. datos internos privados ; } // Codificar en otro lugar // Crear instancias de un objeto con el constructor anterior Ejemplo e = new Ejemplo ( 42 ); Un constructor que toma cero 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. estan escritos asi
clase FooBar { constructor ( baz ) { this . baz = baz } } Esto se puede instanciar como tal.
const foo = nueva FooBar ( '7' ) El equivalente de esto antes de ES6 era crear una función que crea una instancia de un objeto como tal.
función FooBar ( baz ) { este . baz = baz ; } Esto se crea una instancia de la misma manera que el anterior.
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 constructordelante del nombre (en lugar de procedureo function). Puede tener cualquier nombre, aunque la convención es tener Createun 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 ; Nombre de propiedad pública : cadena leída FName ; constructor Crear ( UNNombre : cadena ) ; fin ; constructor TPerson . Crear ( UNNombre : cadena ) ; comenzar FName := AName ; fin ; var Persona : TPersona ; comenzar Persona := TPersona . Crear ( 'Pedro' ) ; // 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 construido 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 ;;let alonzo = nueva persona "Alonzo" "Iglesia" en (*Hola, soy Alonzo Church.*)print_endline alonzo # get_last_name (*Iglesia*)En PHP versión 5 y superiores, 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. Generalmente se usa para realizar inicializaciones automáticamente, como inicializaciones de propiedades. Los constructores también pueden aceptar argumentos, en cuyo caso, cuando newse escribe la declaración, también es necesario 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 sólo puede declarar un máximo de un método constructor. Los métodos estáticos, las clases de fábrica o los argumentos de constructor opcionales son algunas formas de facilitar múltiples formas de crear objetos de una clase PHP.
En Perl versión 5, por defecto, los constructores son métodos de fábrica , es decir, métodos que crean y devuelven el objeto, es decir, concretamente crean y devuelven una referencia bendecida. 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 denomina new , aunque se permite nombrarlo de otra manera o tener varios constructores. Por ejemplo, una clase Persona puede tener un constructor llamado new y un constructor new_from_file que lee un archivo para los atributos de Person y new_from_person que usa otro objeto Person como plantilla.
paquete Persona ; # En Perl los constructores se denominan 'nuevos' por convención. sub new { # El nombre de la clase se pasa implícitamente como 0.º argumento. mi $clase = turno ; # Valores de atributos predeterminados, si tiene alguno. mis %predeterminados = ( foo => "barra" ); # Inicializar atributos como una combinación de valores predeterminados y argumentos pasados. mi $self = { %defaults , @_ }; # Verifique los argumentos requeridos, invariantes de clase, etc. if ( not wanted $self -> { first_name } ) { die "Falta un atributo obligatorio en Persona->new(): first_name" ; } if ( no definido $self -> { apellido } ) { die "Falta atributo obligatorio en Persona->nuevo(): apellido" ; } if ( definido $self -> { edad } y $self -> { edad } < 18 ) { die "Valor de atributo no válido en Persona->new(): edad < 18" ; } # Perl hace que un objeto pertenezca a una clase mediante 'bless'. bendito $self , $class ; devolver $ uno mismo ; } 1 ; En el sistema de objetos Moose para Perl, la mayor parte de este texto estándar se puede omitir, se crea un nuevo valor predeterminado , se pueden especificar atributos y si se pueden configurar, restablecer o si son necesarios. Además, cualquier funcionalidad adicional del constructor se puede incluir en un método BUILD que llamará el constructor generado por Moose, después de haber verificado los argumentos. Se puede especificar un método BUILDARGS para manejar argumentos del constructor que no estén en formato hashref/key => value.
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') tiene nombre_primer => ( is => 'ro' , isa => 'Str' , requerido => 1 ); # el apellido (una cadena) solo se puede configurar en el momento de la construcción ('ro') tiene apellido => ( is => 'ro' , isa => 'Str' , requerido => 1 ); # la edad (entero) se puede modificar después de la construcción ('rw') y no es necesario # pasarla como constructor. También crea un método 'has_age' que devuelve # true si se ha establecido la edad has age => ( is => 'rw' , isa => 'Int' , predicate => 'has_age' ); # Verifique los requisitos personalizados sub BUILD { my $self = shift ; if ( $self -> has_age && $self -> edad < 18 ) { # no mueren menores de 18 años "No se permiten personas menores de 18" ; } } 1 ; En ambos casos, la clase Persona se inicia así:
utilizar Persona ; mi $p = Persona -> nuevo ( nombre => 'Sam' , apellido => 'Ashe' , edad => 42 ); En Python , los constructores están definidos por 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 __init__. Si un método constructor no está definido en la clase, se llamará al siguiente que se encuentre en el Orden de resolución de métodos de la clase. [14]
En el caso típico, sólo __init__es necesario definir el método. (La excepción más común es para objetos inmutables).
>>> clase EjemploClase : ... def __new__ ( cls , valor ): ... print ( "Creando nueva instancia..." ) ... # Llama al constructor de la superclase para crear la instancia. ... instancia = super ( ExampleClass , cls ) . __new__ ( cls ) ... instancia de devolución ... def __init__ ( self , valor ): ... print ( "Iniciando instancia ..." ) ... self . carga útil = valor >>> instancia de ejemplo = Clase de ejemplo ( 42 ) Creando nueva instancia... Inicializando instancia... >>> print ( instancia de ejemplo . carga útil ) 42 Las clases normalmente actúan como fábricas de 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, se permite que el __new__método devuelva algo que no sea una instancia de la clase para fines especializados. En ese caso, __init__no se invoca. [15]
En Raku , se pueden omitir aún más textos repetitivos, dado que se hereda un nuevo método predeterminado, se pueden especificar atributos y si se pueden configurar, restablecer o si son necesarios. Además, se puede incluir cualquier funcionalidad de constructor adicional en un método BUILD que se llamará para permitir una inicialización personalizada. Se puede especificar un método TWEAK para posprocesar cualquier atributo ya (implícitamente) inicializado.
clase Persona { tiene Str $.se requiere el nombre ; # El nombre (una cadena) solo se puede establecer en # el momento de la construcción (el . significa "público"). tiene Str $ .se requiere apellido ; # El apellido (una cadena) solo se puede establecer en # el momento de la construcción (¡a! significaría "privado"). tiene Int $.age es rw ; # La edad (un número entero) se puede modificar después de # la construcción ('rw') y no es necesaria # durante la creación de instancias del objeto. # Cree un método de 'nombre completo' que devuelva el nombre completo de la persona. # Se puede acceder a este método fuera de la clase. método nombre completo { $!nombre . tc ~ " " ~ $!apellido . tc } # Crea un método 'has-age' que devuelve verdadero si se ha establecido la edad. # Este método se usa sólo dentro de la clase, por lo que se declara como "privado" # anteponiendo su nombre a ! método ! tiene-edad { yo . edad . definido } # Verifique el método de requisitos personalizados TWEAK { if self ! has-age && $!age < 18 { # No menores de 18 años mueren "No hay personas menores de 18 años" ; } }}La clase Persona se crea una instancia de esta manera:
mi $p0 = Persona . nuevo ( nombre => 'Sam' , apellido => 'Ashe' , edad => 42 ); mi $p1 = Persona . nuevo ( nombre => 'gracia' , apellido => 'tolva' ); decir $p1 . nombre completo (); # SALIDA: «Grace Hopper»Alternativamente, los parámetros nombrados se pueden especificar usando la sintaxis de pares de dos puntos en Perl 6:
mi $p0 = Persona . nuevo (: nombre <Sam> ,: apellido <Ashe> ,: edad ( 42 )); mi $p1 = Persona . nuevo (: nombre <Grace> ,: apellido <Hopper> );Y si ha configurado variables con nombres idénticos a los parámetros nombrados, puede usar un atajo que usará el nombre de la variable para el parámetro nombrado:
mi $nombre = "Sam" ; mi $apellido = "Ashe" ; mi $edad = 42 ; mi $p0 = Persona . nuevo ( : $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(principal):001:0> clase EjemploClase irb(principal):002:1> def inicializar irb(principal):003:2> pone "Hola" irb(principal):004:2> fin irb(principal) :005:1> fin => nil irb(principal):006:0> EjemploClase . nuevo 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 End Sub End Class 'código en otro lugar ' instanciando un objeto con el constructor anterior Dim foo As New Foobar ( ".NET" )