En la programación orientada a objetos basada en clases , un constructor (abreviatura: ctor ) es un tipo especial de subrutina llamada para crear un objeto . Prepara el nuevo objeto para su uso, a menudo aceptando argumentos que el constructor usa para establecer las variables de 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 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 formas, utilizando múltiples clases o diferentes esquemas de asignación, como un grupo de objetos .
Tipos
Constructores parametrizados
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 del constructor. 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. Si queremos inicializar campos de la clase con sus propios valores, utilice un constructor parametrizado.
class Example { public : Example (); 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.
Constructores predeterminados
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 idioma. Puede inicializar miembros de datos a cero u otros valores iguales, o puede que no haga nada en absoluto. En Java, un "constructor predeterminado" se refiere a un constructor nular 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 nular de 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).
#include clase Estudiante { público : Estudiante ( int a = 0 , int b = 0 ); // Constructor predeterminado. int a ; int b ; };
Copiar constructores
Como C ++, Java también es compatible con "Copiar constructor". 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 suelen abreviarse como ctor o cctor, no tienen nada que ver con los constructores de clases que se utilizan en .NET con la misma abreviatura.
Constructores de conversión
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 generalmente se invocan implícitamente para convertir argumentos u operandos a un tipo apropiado, pero también se pueden llamar explícitamente.
Mover constructores
En C ++, los constructores de movimiento toman una referencia de valor a un objeto de la clase y se utilizan para implementar la transferencia de propiedad de los recursos del objeto de parámetro.
Sintaxis
- Java , C ++ , C # , ActionScript , PHP 4 y MATLAB tienen una convención de nomenclatura en la que los constructores tienen el mismo nombre que la clase a la que están asociados.
- En PHP 5, un nombre recomendado para un constructor es
__construct
. Para compatibilidad con versiones anteriores, se llamará a un método con el mismo nombre que la clase si__construct
no se puede encontrar el método. Desde PHP 5.3.3, esto funciona solo para clases sin espacios de nombres. [1] - En PHP 7, siempre debe nombrar al constructor como
__construct
. Los métodos con el mismo nombre que la clase desencadenarán un error de nivel E_DEPRECATED. [1] - En Perl , los constructores se denominan, por convención, "nuevos" y tienen que realizar una buena cantidad de creación de objetos.
- En el sistema de objetos de Moose para Perl, los constructores (denominados nuevos ) se crean automáticamente y se amplían especificando un método BUILD .
- En Visual Basic .NET , el constructor se llama "
New
". - En Python , el constructor se divide en dos métodos, "
__new__
" y "__init__
". El__new__
método es responsable de asignar memoria para la instancia y recibe la clase como un argumento (convencionalmente llamado "cls
"). El__init__
método (a menudo llamado "el inicializador") se pasa a la instancia recién creada como un argumento (convencionalmente llamado "self
"). [2] - Los constructores de Object Pascal se identifican con la palabra clave "
constructor
" y pueden tener nombres definidos por el usuario (pero en su mayoría se llaman "Create
"). - En Objective-C , el método constructor se divide en dos métodos, "
alloc
" y "init
" con elalloc
método reservando (asignando) memoria para una instancia de la clase, y elinit
método manejando la mayor parte de la inicialización de la instancia. Una llamada al método "new
" invoca tanto el métodoalloc
como elinit
método, para la instancia de la clase.
Organización de la memoria
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 de valor, pero estos objetos de tipo de 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 new y se crean en el montón cuando se invoca el constructor con el operador new. Los objetos de pila se eliminan implícitamente cuando salen del alcance, mientras que los objetos de montón deben eliminarse implícitamente mediante un destructor o explícitamente mediante el operador de eliminación .
Detalles del idioma
Java
En Java , los constructores se diferencian de otros métodos en que:
- Los constructores nunca tienen un tipo de retorno explícito.
- Los constructores no se pueden invocar directamente (la palabra clave “
new
” los invoca). - Los constructores no deben tener modificadores sin acceso.
Los constructores de Java realizan las siguientes tareas en el siguiente orden:
- Llame al constructor predeterminado de la superclase si no se define ningún constructor.
- Inicialice las variables miembro a los valores especificados.
- Ejecuta el cuerpo del constructor.
Java permite a los usuarios llamar a un constructor en otro constructor usando una this()
palabra clave. Pero this()
debe ser la primera declaración. [3]
class Example { Example () // Constructor no parametrizado { this ( 1 ); // Llamada al constructor System . fuera . println ( "0-arg-cons" ); } Ejemplo ( int a ) // Constructor parametrizado { System . fuera . println ( "1-arg-cons" ); } } public static void main ( String [] args ) { Ejemplo e = new Example (); }
Java proporciona acceso al constructor de la superclase a través de la super
palabra clave.
public class Example { // Definición del constructor. Ejemplo público () { esto ( 1 ); } // Sobrecarga de un constructor public Example ( int input ) { data = input ; // Esta es una tarea } // Declaración de variable (s) de instancia. datos int privados ; }
// Codificar en otro lugar // Instanciar un objeto con el constructor anterior Ejemplo e = nuevo Ejemplo ( 42 );
Un constructor que toma un número cero de argumentos se denomina constructor "sin argumentos" o "sin argumentos". [4]
JavaScript
A partir de ES6, JavaScript tiene constructores directos como muchos otros lenguajes de programación. Están escritos como tales
class FooBar { constructor ( baz ) { this . baz = baz } }
Esto se puede instanciar como tal
const foo = new FooBar ( '7' )
El equivalente a esto antes de ES6, era crear una función que instancia un objeto como tal
function FooBar ( baz ) { this . baz = baz ; }
Esto se instancia de la misma manera que arriba.
Visual Basic .NET
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" )
C#
Ejemplo de constructor de C # :
public class MyClass { privado int a ; cadena privada b ; // Constructor public MyClass () : this ( 42 , "cadena" ) { } // Sobrecargar un constructor public MyClass ( int a , string b ) { this . a = a ; esto . b = b ; } }
// Codifica en alguna parte // Instancia de un objeto con el constructor arriba de MyClass c = new MyClass ( 42 , "string" );
Constructor estático de C #
En C # , un constructor estático es un inicializador de datos estáticos. Los constructores estáticos también se denominan constructores de clases . Dado que el método actual 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 (estática o llamada al 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 usa en una clase de programación genérica , los constructores estáticos se llaman en cada nueva instanciación genérica, uno por tipo. También se crean instancias de variables estáticas.
public class MyClass { privado estático int _A ; // Constructor normal static MyClass () { _A = 32 ; } // Constructor estándar por defecto public MyClass () { } }
// Codifique en algún lugar // Instancia de un objeto con el constructor de arriba // justo antes de la instanciación // Se ejecuta el constructor estático variable y _A es 32 MyClass c = new MyClass ();
C ++
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 de 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 necesaria, pero ofrece la oportunidad de proporcionar valores para miembros de datos y evitar declaraciones de asignación separadas. La lista de inicializadores es necesaria si tiene miembros de datos de tipo const o de referencia, o miembros que no tienen lógica de constructor sin parámetros. Las asignaciones ocurren según el orden en el que se declaran los miembros de datos (incluso si el orden en la lista de inicializadores es diferente). [8] La segunda parte es el cuerpo, que es un cuerpo de método normal encerrado entre corchetes.
C ++ permite más de un constructor. Los otros constructores deben tener diferentes parámetros. Además, los constructores que contienen parámetros a los que se les dan valores predeterminados, deben adherirse a la restricción de que no todos los parámetros tienen un valor predeterminado. Esta es una situación que solo 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 de constructor no se heredan y no se puede hacer referencia a sus direcciones. Cuando se requiere asignación de memoria, los operadores new y delete 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 usa 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 tiene miembros asignados dinámicamente (o identificadores a otros recursos), porque puede conducir a llamadas dobles para eliminar (o liberación doble de recursos) después de 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, el constructor de copia de objetos se llamará implícitamente, 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 una, 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 los tres .
F#
En F # , un constructor puede incluir cualquiera de las declaraciones let
o do
definidas en una clase. let
las sentencias definen campos privados y las do
sentencias ejecutan código. Se pueden definir constructores adicionales usando la new
palabra clave.
type MyClass (_ a : int , _ b : string ) = class // 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 "Sin parámetro dado" end
// Codifica en alguna parte // instancia de 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 ( "cadena" ) let c4 = MyClass () // la palabra clave "nueva" es opcional
Eiffel
En Eiffel , las rutinas que inicializan nuevos objetos se denominan procedimientos de creación . Los procedimientos de creación tienen las siguientes características:
- Los procedimientos de creación no tienen un tipo de retorno explícito (por definición de procedimiento ). [a]
- Se nombran los procedimientos de creación.
- Los procedimientos de creación se designan por su nombre como procedimientos de creación en el texto de la clase.
- Los procedimientos de creación se pueden invocar explícitamente para reinicializar objetos existentes.
- Cada clase efectiva (es decir, concreta o no abstracta) debe designar al menos un procedimiento de creación.
- Los procedimientos de creación deben dejar el objeto recién inicializado en un estado que satisfaga el invariante de clase. [B]
Aunque la creación de objetos implica algunas sutilezas, [9] la creación de un atributo con una declaración típica x: T
como se expresa en una instrucción de creación create x.make
consta de la siguiente secuencia de pasos:
- Cree una nueva instancia directa de type
T
. [C] - Ejecute el procedimiento de creación
make
en la instancia recién creada. - Adjunte el objeto recién inicializado a la entidad
x
.
En el primer fragmento a continuación, POINT
se define la clase . El procedimiento make
se codifica después de la palabra clave feature
.
La palabra clave create
introduce 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 ANY
y el make
procedimiento codificado dentro de la clase.
class POINT crear default_create , hacercaracterística make ( a_x_value : REAL ; a_y_value : REAL ) do x : = a_x_value y : = a_y_value end x : REAL - Coordenada X y : REAL - Coordenada Y ...
En el segundo fragmento, una clase que es un cliente POINT
tiene declaraciones my_point_1
y my_point_2
de tipo POINT
.
En código de procedimiento, my_point_1
se crea como origen (0.0, 0.0). Dado que no se especifica ningún procedimiento de creación, se utiliza el procedimiento default_create
heredado de la clase ANY
. Esta línea podría haber sido codificada create my_point_1.default_create
. Solo los procedimientos nombrados como procedimientos de creación se pueden usar en una instrucción con la create
palabra clave. A continuación, se muestra una instrucción de creación para my_point_2
proporcionar valores iniciales para las my_point_2
coordenadas de. La tercera instrucción realiza una llamada de instancia ordinaria al make
procedimiento para reinicializar la instancia adjunta my_point_2
con diferentes valores.
my_point_1 : POINT my_point_2 : POINT ... crear my_point_1 crear my_point_2 . hacer ( 3.0 , 4.0 ) mi_punto_2 . hacer ( 5.0 , 8.0 ) ...
CFML
CFML usa un método llamado " init
" como método constructor.
Cheese.cfc
componente { // propiedades property name = "cheeseName" ; // función constructora Cheese init ( cadena requerida cheeseName ) { variables . cheeseName = argumentos . cheeseName ; devuelve esto ; } }
Crea una instancia de un queso.
myCheese = nuevo queso ( 'Cheddar' );
Desde ColdFusion 10, [10] CFML también ha admitido la especificación del nombre del método constructor:
componente initmethod = "Cheese" { // propiedades property name = "cheeseName" ; // función constructora Cheese Cheese ( cadena requerida cheeseName ) { variables . cheeseName = argumentos . cheeseName ; devuelve esto ; } }
Objeto Pascal
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 constructor
delante del nombre (en lugar de procedure
o function
). Puede tener cualquier nombre, aunque la convención es tener un Create
prefijo, como en CreateWithFormatting
. Creación de una instancia de una clase funciona como llamar a un método estático de una clase: TPerson.Create('Peter')
.
programa OopProgram ;escriba TPerson = clase privada FName : cadena ; propiedad pública Name : string read FName ; constructor Create ( AName : string ) ; terminar ; constructor TPerson . Crear ( AName : string ) ; comenzar FName : = AName ; terminar ;var Persona : TPerson ; comenzar Persona : = TPpersona . Crear ( 'Peter' ) ; // asigna una instancia de TPerson y luego llama a TPerson.Create con el parámetro AName = 'Peter' end .
Perl 5
En la versión 5 del lenguaje de programación Perl , por defecto, los constructores son métodos de fábrica , es decir, métodos que crean y devuelven el objeto, lo que significa concretamente crear y devolver 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 llama nuevo , aunque se le permite nombrarlo de otra manera, o tener varios constructores. Por ejemplo, una clase Person puede tener un constructor llamado new así como 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.
persona del paquete ; # 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 atributo predeterminados, si los tiene. my % defaults = ( foo => "bar" ); # Inicializar atributos como una combinación de valores predeterminados y argumentos pasados. my $ self = { % valores predeterminados , @_ }; # Verifique los argumentos requeridos, invariante de clase, etc. if ( no definido $ self -> { first_name } ) { die "Falta el atributo obligatorio en Person-> new (): first_name" ; } if ( no definido $ self -> { last_name } ) { die "Falta el atributo obligatorio en Person-> new (): last_name" ; } if ( definido $ self -> { age } y $ self -> { age } < 18 ) { die "Valor de atributo no válido en Person-> new (): age <18" ; } # Perl hace que un objeto pertenezca a una clase por 'bendecir'. bendiga $ a sí mismo , $ clase ; return $ self ; } 1 ;
Perl 5 con Moose
Con el sistema de objetos Moose para Perl, la mayor parte de este texto estándar se puede omitir, se crea un nuevo predeterminado , se pueden especificar atributos, así como si se pueden configurar, restablecer o son obligatorios. Además, cualquier funcionalidad extra 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 de constructor que no estén en formato hashref / key => value.
persona del paquete ; # habilitar la construcción de objetos al estilo Moose use Moose ;# el nombre (una cadena) solo se puede establecer en el momento de la construcción ('ro') tiene first_name => ( is => 'ro' , isa => 'Str' , required => 1 ); # El apellido (una cadena) solo se puede establecer en el momento de la construcción ('ro') tiene last_name => ( is => 'ro' , isa => 'Str' , required => 1 ); # age (Integer) se puede modificar después de la construcción ('rw'), y no es necesario # pasarlo para ser constructor. También crea un método 'has_age' que devuelve # verdadero 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 -> age < 18 ) { # no menores de 18 años mueren "No menores de 18 años" ; } } 1 ;
En ambos casos, la clase Person se inicia así:
use Person ; my $ p = Persona -> nuevo ( primer_nombre => 'Sam' , apellido => 'Ashe' , edad => 42 );
Raku
Con Raku , se pueden omitir aún más textos estándar, dado que se hereda un nuevo método predeterminado , se pueden especificar atributos, así como si se pueden configurar, restablecer o son obligatorios. Además, cualquier funcionalidad adicional del constructor se puede incluir en un método BUILD que será llamado para permitir una inicialización personalizada. Se puede especificar un método TWEAK para postprocesar cualquier atributo ya inicializado (implícitamente).
class Person { tiene Str $. Se requiere el primer nombre ; # El nombre (una cadena) solo se puede establecer # en el momento de la construcción (. Significa "público"). tiene Str $ .last-name es obligatorio ; # 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 instanciación 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 full-name { $! first-name . tc ~ "" ~ $! apellido . tc } # Cree 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 . edad . definido } # Verifique el método de requisitos personalizados TWEAK { if self ! has-age && $! age < 18 { # No mueren menores de 18 años "Ninguna persona menor de 18 años" ; } }}
La clase Person se instancia así:
my $ p0 = Persona . nuevo ( nombre => 'Sam' , apellido => 'Ashe' , edad => 42 );my $ p1 = Persona . nuevo ( nombre => 'gracia' , apellido => 'hopper' );digamos $ 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:
my $ p0 = Persona . nueva (: nombre de pila ,: last-name ,: edad ( 42 ));my $ p1 = Persona . nueva (: nombre de pila ,: last-name );
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:
my $ first-name = "Sam" ;my $ apellido = "Ashe" ;my $ edad = 42 ;my $ p0 = Persona . nueva (: $ nombre de pila ,: $ último nombre ,: $ edad );
PHP
En PHP versión 5 y superior, el constructor es un método llamado __construct()
(observe que es un guión bajo doble), que la palabra clave new
llama automáticamente después de crear el objeto. Por lo general, se usa para realizar inicializaciones automáticas, como inicializaciones de propiedades. Los constructores también pueden aceptar argumentos, en cuyo caso, cuando new
se 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 { $ esto -> nombre = $ nombre ; } función pública getName () : string { return $ this -> nombre ; } }
Pitón
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 __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 . [11]
En el caso típico, solo __init__
es necesario definir el método. (La excepción más común es para objetos inmutables).
>>> class ExampleClass : ... def __new__ ( cls , value ): ... print ( "Creando nueva instancia ..." ) ... # Llame al constructor de la superclase para crear la instancia. ... instancia = super ( ExampleClass , cls ) . __new__ ( cls ) ... return instancia ... def __init__ ( self , value ): ... print ( "Inicializando instancia ..." ) ... self . de carga útil = valor >>> exampleInstance = ExampleClass ( 42 ) Crear nueva instancia ... La inicialización de ejemplo ... >>> print ( exampleInstance . de carga útil ) 42
Las 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), siendo la llamada 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 que no sea una instancia de la clase para fines especializados. En ese caso, __init__
no se invoca. [12]
Rubí
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 ExampleClass IRB (principal): 002: 1> def initialize IRB (principal): 003: 2> pone "Hola" IRB (principal): 004: 2> final del IRB (principal) : 005: 1> end => nil irb (principal): 006: 0> ExampleClass . nuevo Hola => #
OCaml
En OCaml , hay un constructor. Los parámetros se definen justo después del nombre de la clase. Se pueden usar para inicializar variables de instancia y son accesibles en toda la clase. Un método oculto anónimo llamado initializer
permite evaluar una expresión inmediatamente después de que se haya construido el objeto. [13]
class person first_name last_name = object val full_name = first_name ^ "" ^ last_name initializer print_endline ( "Hola, soy" ^ full_name ^ "." ) método get_last_name = last_name end ;;let alonzo = nueva persona "Alonzo" "Iglesia" en (* Hola, soy Alonzo Iglesia. *)print_endline alonzo # get_last_name (* Iglesia *)
Ver también
- Sitio de asignación
- Patrón creacional
- Incinerador de basuras
- Constructor global en C ++, y su contraparte C, atributo de función ((constructor))
Notas
- ^ Las rutinas de Eiffelson procedimientos o funciones . Los procedimientos nunca tienen un tipo de retorno. Las funciones siempre tienen un tipo de retorno.
- ^ Debido a que el invariante de clase heredado debe satisfacerse, no hay una llamada obligatoria a los constructores de los padres.
- ^ El estándar Eiffel requiere que los campos se inicialicen en el primer acceso, por lo que no es necesario realizar la inicialización de campo predeterminada durante la creación del objeto.
Referencias
- ^ a b c Constructores y destructores , de la documentación en línea de PHP
- ^ Modelo de datos , de la documentación en línea de Python
- ^ Detalles sobre Constructor en java
- ^ "Proporcionar constructores para sus clases" . Oracle Corporation. 2013 . Consultado el 20 de diciembre de 2013 .
- ^ "Fabulosas aventuras en la codificación" . Eric Lippert. 2013-02-06 . Consultado el 5 de abril de 2014 .
- ^ Ensamblador experto de .NET 2.0 IL . APulse. 2006-01-01. ISBN 9781430202233. Consultado el 5 de abril de 2014 .
- ^ Constructor estático en C # en MSDN
- ^ https://stackoverflow.com/questions/1242830/constructor-initialization-list-evaluation-order Constructor
- ^ Documento de especificaciones Eiffel ISO / ECMA
- ^ CFComponent
- ^ Modelo de datos
- ^ Modelo de datos
- ^ Manual de OCaml