Introducción a Constructor en C #
Constructor juega un papel muy importante en la programación orientada a objetos. Comprendamos el papel del constructor en C # con la ayuda de los siguientes puntos:
- Un constructor es un método especial presente dentro de una clase que se encarga de inicializar las variables de la clase.
- Su nombre es el mismo que el nombre de la clase.
- Se ejecuta automáticamente cuando creamos una instancia de la clase.
- Un constructor no devuelve ningún valor.
- Si no definimos un constructor, la clase que se llama el constructor predeterminado siempre proporciona un constructor implícito.
Sintaxis:
public class Student()
(
//constructor
public Student()
(
//code
)
)
Aquí, Public Student () es un método que no tiene ningún tipo de retorno, ni siquiera es nulo y su nombre es el mismo que el nombre de la clase, es decir, 'Estudiante'. Por lo tanto, este método es el constructor de esta clase.
Cuando crearemos un objeto de esta clase usando:
Student obj = new Student();
Entonces se ejecutará el código dentro del constructor.
Trabajo de Constructor en C #
1. El constructor inicializa los miembros de datos para el nuevo objeto. Es invocado por el operador 'nuevo' inmediatamente después de que la memoria se asigna al nuevo objeto.
2. Los constructores explícitos (constructores definidos por el usuario) pueden ser sin parámetros o parametrizados. Si se parametriza, los valores pasados al constructor se pueden asignar a los miembros de datos de la clase.
3. El constructor implícito inicializa las variables de la clase con el mismo valor incluso si creamos múltiples instancias de esa clase.
Ejemplo:
Código:
using System;
public class ConstructorDemo
(
public int num = 10;
public static void Main()
(
ConstructorDemo obj1 = new ConstructorDemo();
ConstructorDemo obj2 = new ConstructorDemo();
ConstructorDemo obj3 = new ConstructorDemo();
Console.WriteLine("obj1.num = "+obj1.num+"\nobj2.num = "+obj2.num
+"\nobj3.num = "+obj3.num);
)
)
Salida:
Representación pictórica del programa anterior:
4. El constructor explícito con parámetros nos permite inicializar las variables de la clase con un valor diferente cada vez que creamos una instancia de esa clase.
Ejemplo:
Código:
using System;
public class ConstructorDemo
(
public int num;
//explicit constructor
public ConstructorDemo(int num)
(
this.num = num;
)
public static void Main()
(
ConstructorDemo obj1 = new ConstructorDemo(10);
ConstructorDemo obj2 = new ConstructorDemo(20);
ConstructorDemo obj3 = new ConstructorDemo(30);
Console.WriteLine("obj1.num = "+obj1.num+"\nobj2.num = "+obj2.num
+"\nobj3.num = "+obj3.num);
)
)
Salida:
Representación pictórica del programa anterior:
Los 5 tipos principales de constructor en C #
C # proporciona cinco tipos de constructores. Son los siguientes:
1. Constructor predeterminado
- Un constructor sin ningún parámetro se llama Constructor predeterminado. Si no lo definimos explícitamente, el compilador lo proporcionará implícitamente.
- En tal caso, podemos llamarlo constructor implícito. El constructor implícito o predeterminado inicializa todos los miembros de datos de la clase con sus valores predeterminados, como todos los campos numéricos a cero y todos los campos de cadena y objeto a nulo.
Ejemplo:
Código:
using System;
public class DefaultConstructor
(
public int num;
public string str;
)
public class Demo
(
public static void Main()
(
DefaultConstructor obj = new DefaultConstructor();
Console.WriteLine("obj.num = "+obj.num+"\nobj.str = "+obj.str);
)
)
Salida:
2. Constructor parametrizado
El constructor con al menos un parámetro se llama Constructor parametrizado. Se pueden pasar parámetros al constructor mientras se crea la instancia de la clase. Nos permite inicializar cada instancia de una clase con diferentes valores.
Ejemplo:
Código:
using System;
public class ParameterizedConstructor
(
public int num;
public string str;
//parameterized constructor
public ParameterizedConstructor(int num, string str)
(
this.num = num;
this.str = str;
)
)
public class Demo
(
public static void Main()
(
//passing values to constructor while creating instance
ParameterizedConstructor obj = new ParameterizedConstructor(50, "constructor");
Console.WriteLine("obj.num = "+obj.num+"\nobj.str = "+obj.str);
)
)
Salida:
3. Copiar constructor
Es un constructor parametrizado que toma el mismo objeto de clase como parámetro. Copia el valor del objeto existente (que se pasa como parámetro) al objeto recién creado instanciado por el constructor. Podemos decir que copia datos de un objeto a otro objeto.
Ejemplo:
Código:
using System;
public class CopyConstructor
(
public int num;
public CopyConstructor(int num)
(
this.num = num;
)
//copy constructor
public CopyConstructor(CopyConstructor obj)
(
num = obj.num;
)
)
public class Demo
(
public static void Main()
(
CopyConstructor obj1 = new CopyConstructor(50);
//passing same class's object as parameter
CopyConstructor obj2 = new CopyConstructor(obj1);
Console.WriteLine("Original object:");
Console.WriteLine("obj1.num = "+obj1.num);
Console.WriteLine("\nCopied object:");
Console.WriteLine("obj2.num = "+obj2.num);
)
)
Salida:
4. Constructor estático
- Se puede definir prefijando el nombre del constructor con una palabra clave. Está implícitamente definido por el compilador (si no se define explícitamente) si la clase contiene alguna variable estática.
- Es el primer bloque que se ejecutará en la clase y se llamará automáticamente. Se ejecutará solo una vez, independientemente del número de instancias de clase. No tiene parámetros y no acepta ningún modificador de acceso.
Ejemplo:
Código:
using System;
public class StaticConstructor
(
//static constructor
static StaticConstructor()
(
Console.WriteLine("Static constructor executed");
)
public static void Display()
(
Console.WriteLine("\nDisplay method executed");
)
)
public class Demo
(
public static void Main()
(
StaticConstructor.Display();
)
)
Salida:
5. Constructor privado
El constructor creado con un especificador privado se denomina constructor privado. No podemos crear una instancia de la clase si contiene solo un constructor privado y no permite que otras clases se deriven de esta clase. Se usa en una clase que contiene solo miembros estáticos.
Ejemplo:
Código:
using System;
public class PrivateConstructor
(
public static int num = 100;
//private constructor
private PrivateConstructor()
(
)
)
public class Demo
(
public static void Main()
(
//PrivateConstructor obj = new PrivateConstructor(); //Error
Console.WriteLine("num = "+PrivateConstructor.num);
)
)
Salida:
Conclusión
Si definimos cualquier tipo de constructor en la clase, entonces no habrá ningún constructor implícito en la clase proporcionada por el compilador. Al igual que los métodos, los constructores parametrizados también se pueden sobrecargar con diferentes números de parámetros. Los constructores definidos implícitamente por el compilador son siempre públicos.
Artículo recomendado
Esta es una guía de Constructor en C #. Aquí discutimos los tipos de Constructor en C # y su funcionamiento junto con la implementación y salida del código. También puede consultar nuestros otros artículos sugeridos para obtener más información:
- Constructor en JavaScript y Tipos
- ¿Qué es el generador de números aleatorios en C #?
- Constructor en C ++ y Tipos
- Copiar constructor en C # (ejemplos)
- Constructor estático en Java | Trabajando | Aplicaciones