Sobrecarga de métodos
La sobrecarga de métodos es una característica en programación orientada a objetos que
permite definir varios métodos con el mismo nombre en la misma clase, pero con diferentes
parámetros. Esto significa que los métodos tienen la misma firma de nombre pero una firma
diferente de parámetros.
Un ejemplo de sobrecarga de métodos en C# es el siguiente:
public class Calculadora {
public int Sumar(int a, int b) {
return a + b;
public int Sumar(int a, int b, int c) {
return a + b + c;
public double Sumar(double a, double b) {
return a + b;
En este ejemplo, la clase Calculadora tiene tres métodos llamados Sumar, pero cada uno de ellos
tiene diferentes parámetros. El primer método suma dos enteros, el segundo método suma tres
enteros y el tercer método suma dos números de punto flotante.
Sobrecarga de constructores
La recarga de constructores también es una característica en programación orientada a objetos
que permite definir varios constructores con el mismo nombre en la misma clase, pero con
diferentes parámetros. Esto significa que los constructores tienen la misma firma de nombre
pero una firma diferente de parámetros.
Un ejemplo de recarga de constructores en C# es el siguiente:
public class Persona {
public string Nombre { get; set; }
public int Edad { get; set; }
public Persona(string nombre) {
[Link] = nombre;
[Link] = 0;
public Persona(string nombre, int edad) {
[Link] = nombre;
[Link] = edad;
En este ejemplo, la clase Persona tiene dos constructores llamados Persona, pero cada uno de
ellos tiene diferentes parámetros. El primer constructor crea una nueva instancia de Persona
con solo un nombre y establece la edad en cero. El segundo constructor crea una nueva instancia
de Persona con un nombre y una edad.
Sobrecarga de operadores
La sobrecarga de operadores es una característica en programación orientada a objetos que
permite definir el comportamiento de los operadores comunes, como la adición (+), la
multiplicación (*), la comparación (==), etc., para los tipos de datos personalizados. Esto significa
que se pueden definir operadores personalizados para las clases y estructuras creadas por el
programador.
Un ejemplo de sobrecarga de operadores en C# es el siguiente
public class Punto {
public int X { get; set; }
public int Y { get; set; }
public Punto(int x, int y) {
this.X = x;
this.Y = y;
public static Punto operator +(Punto p1, Punto p2) {
return new Punto(p1.X + p2.X, p1.Y + p2.Y); En este ejemplo, se ha sobrecargado el
operador de adición (+) para la clase
} Punto. Se ha definido un método estático
} llamado operator + que toma dos
argumentos de tipo Punto y devuelve un
nuevo objeto Punto con las coordenadas
public class Program { sumadas. Luego, en el método Main, se
han creado dos instancias de Punto y se
static void Main(string[] args) { han sumado utilizando el operador
sobrecargado (+), creando una nueva
Punto p1 = new Punto(1, 2);
instancia de Punto con las coordenadas
Punto p2 = new Punto(3, 4); sumadas y almacenándola en la variable
p3. Finalmente, se ha impreso la
Punto p3 = p1 + p2;
coordenada de p3 en la consola.
[Link]($"({p3.X}, {p3.Y})"); // Salida: (4, 6)
}
En C#, los operadores se pueden clasificar en dos categorías: operadores unarios y operadores
binarios.
Un operador unario actúa sobre un solo operando, mientras que un operador binario actúa
sobre dos operandos. En ambos casos, el operador realiza una operación en los operandos y
devuelve un valor.
A continuación, se muestran algunos ejemplos de operadores unarios y binarios en C#:
Operadores unarios:
Operador de incremento ++: este operador incrementa en uno el valor de la variable.
int a = 10;
a++;
// El valor de a es ahora 11
Operador de negación !: este operador invierte el valor lógico de un operando booleano.
bool b = true;
bool c = !b;
// El valor de c es ahora false
Operador de complemento a uno ~: este operador invierte cada bit de un operando entero.
int a = 42; // 00101010 en binario
int b = ~a; // 11010101 en binario
// El valor de b es -43 en decimal
Operadores binarios:
Operador de suma +: este operador suma dos operandos.
int a = 10;
int b = 5;
int c = a + b;
// El valor de c es ahora 15
Operador de multiplicación *: este operador multiplica dos operandos.
int a = 10;
int b = 5;
int c = a * b;
// El valor de c es ahora 50
Operador de comparación ==: este operador compara si dos operandos son iguales.
int a = 10;
int b = 5;
bool c = a == b;
// El valor de c es false
C# también admite la sobrecarga de operadores personalizados para clases y estructuras
personalizadas, lo que permite definir el comportamiento de los operadores para tipos
personalizados.