Requisito previo: Constructores en C#
Es bastante similar a la sobrecarga del método . Es la capacidad de redefinir un Constructor en más de una forma. Un usuario puede implementar la sobrecarga de constructores definiendo dos o más constructores en una clase que comparten el mismo nombre. C# puede distinguir los constructores con diferentes firmas. es decir, el constructor debe tener el mismo nombre pero con una lista de parámetros diferente.
Podemos sobrecargar los constructores de diferentes maneras de la siguiente manera:
- Mediante el uso de diferentes tipos de argumentos
- Usando diferente número de argumentos
- Usando diferente orden de argumentos
Al cambiar los tipos de datos de los parámetros
Ejemplo:
public ADD (int a, float b); public ADD (string a, int b);
Aquí el nombre de la clase es ADD . En el primer constructor hay dos parámetros, el primero es int y otro es float y en el segundo constructor, también hay dos parámetros, el primero es de tipo string y el otro es de tipo int .
Aquí los constructores tienen el mismo nombre pero los tipos de parámetros son diferentes, similar al concepto de sobrecarga de métodos.
// C# program to Demonstrate the overloading of
// constructor when the types of arguments
// are different
using System;
class ADD {
int x, y;
double f;
string s;
// 1st constructor
public ADD(int a, double b)
{
x = a;
f = b;
}
// 2nd constructor
public ADD(int a, string b)
{
y = a;
s = b;
}
// showing 1st constructor's result
public void show()
{
Console.WriteLine("1st constructor (int + float): {0} ",
(x + f));
}
// shows 2nd constructor's result
public void show1()
{
Console.WriteLine("2nd constructor (int + string): {0}",
(s + y));
}
}
// Driver Class
class GFG {
// Main Method
static void Main()
{
// Creating instance and
// passing arguments
// It will call the first constructor
ADD g = new ADD(10, 20.2);
// calling the method
g.show();
// Creating instance and
// passing arguments
// It will call the second constructor
ADD q = new ADD(10, "Roll No. is ");
// calling the method
q.show1();
}
}
1st constructor (int + float): 30.2 2nd constructor (int + string): Roll No. is 10
Al cambiar el número de los parámetros
En este caso, utilizaremos dos o más constructores que tengan diferente número de parámetros. Los tipos de datos de los argumentos pueden ser los mismos, pero el número de parámetros será diferente.
Ejemplo:
public ADD (int a, int b); public ADD (int a, int b, int c);
Aquí, el nombre de la clase es ADD . En el primer constructor, el número de parámetros es dos y los tipos de parámetros son int . En el segundo constructor, el número de parámetros es tres y los tipos de parámetros también son int , no hay problema con los tipos de datos.
// C# Program to illustrate the overloading of
// constructor when the number of parameters
// are different
using System;
class ADD {
int x, y;
int f, p, s;
// 1st constructor
public ADD(int a, int b)
{
x = a;
y = b;
}
// 2nd constructor
public ADD(int a, int b, int c)
{
f = a;
p = b;
s = c;
}
// showing 1st constructor's result
public void show()
{
Console.WriteLine("1st constructor (int + int): {0} ",
(x + y));
}
// showing 2nd constructor's result
public void show1()
{
Console.WriteLine("2nd constructor (int + int + int): {0}",
(f + p + s));
}
}
// Driver Class
class GFG {
// Main Method
static void Main()
{
// will call 1st constructor
ADD g = new ADD(10, 20);
// calling method
g.show();
// will call 2nd constructor
ADD q = new ADD(10, 20, 30);
// calling method
q.show1();
}
}
1st constructor (int + int): 30 2nd constructor (int + int + int): 60
Cambiando el Orden de los parámetros
Ejemplo:
public student(double a, int x, string s) public student(string s, int x, double a)
Aquí, los dos constructores tienen los mismos tipos de parámetros, es decir, cada constructor tiene un tipo doble , un tipo int y un parámetro de tipo string , pero las posiciones de los parámetros son diferentes. El compilador invocará al constructor de acuerdo con el orden de sus argumentos.
// C# program to illustrate the overloading of
// constructor by changing the order of parameters
using System;
class student {
public int roll;
public double Height;
public string name;
public student(double a, int x, string s)
{
roll = x;
name = s;
Height = a;
}
// order of the argument is different
// with respect to 1st constructor
public student(string s, int x, double a)
{
Height = a;
roll = x;
name = s;
}
public void show()
{
Console.WriteLine("Roll Number: " + roll);
Console.WriteLine("Height: " + Height + "feet");
Console.WriteLine("Name: " + name);
}
}
// Driver Class
class Geeks {
// Main Method
static void Main()
{
// invoking 1st constructor
student s1 = new student(5.7, 10, "Jhon Peterson");
// invoking 2nd constructor
student s2 = new student("Peter Perker", 11, 6.0);
Console.WriteLine("First Constructor: ");
s1.show();
Console.WriteLine();
Console.WriteLine("Second Constructor: ");
s2.show();
}
}
First Constructor: Roll Number: 10 Height: 5.7feet Name: Jhon Peterson Second Constructor: Roll Number: 11 Height: 6feet Name: Peter Perker
Invocar un constructor sobrecargado usando la palabra clave «esta»
Podemos llamar a un constructor sobrecargado desde otro constructor usando esta palabra clave, pero el constructor debe pertenecer a la misma clase, porque esta palabra clave apunta a los miembros de la misma clase en la que se usa. Este tipo de llamada al constructor sobrecargado también se denomina enstringmiento de constructores .
Ejemplo:
Let the class name is gfg, Now public gfg() public gfg(int a) : this() public gfg(double b) : this(int)
Aquí, el primer constructor es el constructor predeterminado, el segundo y el tercer constructor son constructores parametrizados, donde uno tiene un tipo int y otro tiene un parámetro de tipo doble.
En el segundo constructor, this() invoca al primer constructor, que es el constructor predeterminado . Aquí, después de esta palabra clave solo hay ( ) , lo que significa que el constructor de invocación del compilador que no tiene argumentos, significa constructor predeterminado.
En el tercer constructor, this(int) invoca al segundo constructor que es constructor parametrizado . Aquí, después de esto , hay (int) , lo que significa que el compilador invoca al constructor que tiene un argumento de tipo int .
// C# program to illustrate the invoking of
// overloaded constructor using this keyword
using System;
class GFG {
// Private data members
private int Length, Height;
private double Width;
// Default Constructor
public GFG()
{
Console.WriteLine("Default Constructor Invoked");
}
// The constructor calls the
// Default constructor
public GFG(int l, double w) : this()
{
Console.WriteLine("Parameterized Constructor in 2nd Constructor");
// assigning value of
// 'Length'and 'Width'
Length = l;
Width = w;
}
// The constructor call the
// parameterized constructor
public GFG(int l, double w, int h) : this(l, w)
{
Console.WriteLine("Parameterized Constructor in 3rd Constructor");
// assign value of 'Height'
Height = h;
}
// Public Method to calculate volume
public double Volume()
{
return (Length * Width * Height);
}
}
// Driver Class
class Geeks {
// Main Method
public static void Main()
{
// Invoking 3rd Constructor
// here Constructor chaining
// came into existence
GFG g = new GFG(10, 20.5, 30);
// calling the 'Volume' Method
Console.WriteLine("Volume is : {0}", g.Volume());
}
}
Default Constructor Invoked Parameterized Constructor in 2nd Constructor Parameterized Constructor in 3rd Constructor Volume is : 6150
Sobrecarga de Copy Constructor
Un constructor parametrizado que contiene un parámetro del mismo tipo de clase se denomina constructor de copia. Básicamente, el constructor de copias es un constructor que copia datos de un objeto en otro objeto. Su uso principal es inicializar una nueva instancia a los valores de una instancia existente.
// C# program to illustrate the
// overloading of Copy Constructor
using System;
class GFG {
public string p1, p2;
public int p3, p4;
// 1st Constructor
public GFG(string x, string y)
{
p1 = x;
p2 = y;
}
// Copy Constructor of 1st Constructor
public GFG(GFG gf)
{
p1 = gf.p1;
p2 = gf.p2;
}
// 2nd Constructor with different
// types pf parameter
public GFG(int a, int b)
{
p3 = a;
p4 = b;
}
// Copy Constructor of 2nd Constructor
// Here number of parameter is different
// with respect to 1st Constructor
public GFG(GFG a, GFG b)
{
p3 = a.p3;
p4 = b.p4;
}
}
// Driver Class
class Geeks {
// Main Method
static void Main()
{
// Create instance to class 'GFG'
GFG g = new GFG("Welcome", "GeeksForGeeks");
// Here 'g' details will copied to 'g1'
GFG g1 = new GFG(g);
Console.WriteLine(g1.p1 + " to " + g1.p2);
// Create instance to class 'GFG'
// with different types of parameter
GFG G = new GFG(10, 20);
// Here 'G' details will copied to 'G1'
GFG G1 = new GFG(G, G);
Console.WriteLine("Overloaded values : {0} and {1}",
G1.p3, G1.p4);
}
}
Welcome to GeeksForGeeks Overloaded values : 10 and 20
Nota:
- El constructor estático no se puede sobrecargar, porque los constructores estáticos son constructores sin parámetros, pero para la sobrecarga, debemos necesitar un constructor parametrizado.
- Private Constructor puede sobrecargarse y podemos usarlo como instancia de esta clase dentro de la misma clase. No se puede acceder a los miembros privados desde fuera de la clase.
Publicación traducida automáticamente
Artículo escrito por SoumikMondal y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA