Introducción a la sobrecarga y anulación en C #

El polimorfismo es uno de los conceptos importantes en C #. Hay dos tipos de polimorfismo, el tiempo de compilación y el tiempo de ejecución. Los conceptos de sobrecarga y anulación se utilizan para lograr esto, respectivamente. Al anular, una clase secundaria puede implementar el método de la clase principal de una manera diferente, pero el método de la clase secundaria tiene el mismo nombre y la misma firma de método que el principal, mientras que en la sobrecarga hay varios métodos en una clase con el mismo nombre y diferentes parámetros.

¿Cómo funciona la anulación y la sobrecarga en C #?

El funcionamiento de anulación y sobrecarga en C # se explica a continuación con ejemplos:

Primordial

Hay algunas palabras clave que usamos para anular, como virtual, override y base.

Sintaxis:

class Parent
(
public virtual void Example() // base class
(
Console.WriteLine(“ parent class”);
)
)
class Child: Parent
(
public override void Example() // derived class
(
base.Example();
Console.WriteLine(“Child class”);
)
)

En esto, se usan palabras clave virtuales y de anulación, lo que significa que la clase base es virtual y la clase secundaria puede implementar esta clase y anular significa que esta clase secundaria tiene el mismo nombre y la misma firma de método que la clase primaria.

Ejemplo 1

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace OverridingExample
(
class Subject // base class
(
public virtual void study() // base class method
(
Console.WriteLine("Study all the subjects");
)
)
class Mathematics: Subject // derived class
(
public override void study() // derived class method
(
Console.WriteLine("Study Mathematics");
)
)
class Program
(
// main method
static void Main(string() args)
(
Subject s = new Mathematics();
s.study();
Console.ReadLine();
)
)
)

En el ejemplo anterior, el nombre de los métodos es el mismo pero su implementación es diferente. La clase base tiene virtual y debido a que la clase secundaria puede implementar el método de clase primaria a su manera. El método de la clase secundaria tiene una anulación de palabras clave que muestra que este método es un método de anulación.

Salida:

Ejemplo # 2

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace OverridingExample
(
class Subject // base class
(
public virtual void study() // base class method
(
Console.WriteLine("Study all the subjects");
)
)
class Mathematics: Subject // derived class
(
public override void study() // derived class method
(
base.study();
Console.WriteLine("Study Mathematics");
)
)
class Program
(
// main method
static void Main(string() args)
(
Mathematics m = new Mathematics();
m.study();
Console.ReadLine();
)
)
)

Salida:

En este ejemplo, la clase derivada tiene una palabra clave base que se usa para llamar al método de la clase base. Entonces, en ese caso, el método derivado se llama después del método de la clase base.

Puntos para recordar:

  • En el concepto primordial, el nombre del método y la firma del método y el modificador de acceso son siempre los mismos que los de la clase primaria y secundaria.
  • El método de la clase principal no puede ser estático.

Sobrecarga

En sobrecarga, hay múltiples métodos con firma de método diferente. A continuación se muestran algunos ejemplos que muestran cómo podemos lograr la sobrecarga variando el número de parámetros, el orden de los parámetros y los tipos de datos de los parámetros.

Ejemplo 1

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace OverloadingExample
(
class Demo
(
public int Sum(int x, int y)
(
int value = x + y;
return value;
)
public int Sum(int x, int y, int z)
(
int value = x + y + z;
return value;
)
public static void Main(string() args) // main method
(
Demo d = new Demo();
int sum1 = d.Sum(24, 28);
Console.WriteLine("sum of the two "
+ "integer value : " + sum1);
int sum2 = d.Sum(10, 20, 30);
Console.WriteLine("sum of the three "
+ "integer value : " + sum2);
Console.ReadLine();
)
)
)

En el ejemplo anterior, hay dos métodos con el mismo nombre pero con un número diferente de parámetros. El primer método consta de dos parámetros, mientras que el segundo tiene tres parámetros. Esto se llama sobrecarga de métodos.

Salida:

Ejemplo # 2

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace OverloadingExample
(
class Demo
(
public int Sum(int x, int y, int z)
(
int value = x + y + z;
return value;
)
public double Sum(double x, double y, double z)
(
double value = x + y + z;
return value;
)
public static void Main(string() args) // main method
(
Demo d = new Demo();
int sum1 = d.Sum(24, 28, 7);
Console.WriteLine("sum of the two "
+ "integer value : " + sum1);
double sum2 = d.Sum(10.0, 20.0, 30.0);
Console.WriteLine("sum of the three "
+ "integer value : " + sum2);
Console.ReadLine();
)
)
)

En el ejemplo anterior, hay dos métodos con el mismo nombre pero sus tipos de datos son diferentes. El primer método tiene un tipo de datos entero, mientras que el segundo tiene un tipo de datos doble. Entonces, en este caso, los parámetros varían debido a los diferentes tipos de datos.

Salida:

Ejemplo # 3

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace OverloadingExample
(
class Demo
(
public void Details(String name, int id)
(
Console.WriteLine("Name " + name + ", "
+ "Id " + id); ;
)
public void Details(int id, string name)
(
Console.WriteLine("Name " + name + ", "
+ "Id " + id);
)
public static void Main(string() args) // main method
(
Demo d = new Demo();
d.Details("John", 10);
d.Details("Joe", 20);
Console.ReadLine();
)
)
)

En el ejemplo anterior, el nombre de los métodos es el mismo pero el orden de los parámetros es diferente. El primer método tiene un nombre y una identificación resp. mientras que el segundo tiene id y nombre respectivamente.

Salida:

Puntos para recordar:

  • En un concepto de sobrecarga, no es posible definir más de un método con los mismos parámetros en caso de orden, tipo y número.
  • No es posible sobrecargar un método basado en los diferentes tipos de retorno.

Ventajas de sobrecargar y anular en C #

  • La sobrecarga es una de las formas de lograr la estática y la anulación es una de las formas en que C # logra el polimorfismo dinámico.
  • Proporciona flexibilidad al usuario y limpieza del código.

Conclusión

La sobrecarga y la anulación juegan un papel importante en el logro del polimorfismo. La anulación permite que la clase derivada se implemente a su manera y, por otro lado, la sobrecarga se trata de métodos con el mismo nombre y varios tipos de implementaciones de parámetros.

Artículos recomendados

Esta es una guía de sobrecarga y anulación en C #. Aquí discutimos el funcionamiento, la sintaxis, las ventajas de sobrecargar y anular en C # con ejemplos e implementación de código. También puede consultar los siguientes artículos para obtener más información:

  1. Objetos en C #
  2. Matrices 2D en C #
  3. Anulación en C #
  4. Intercambio en C #
  5. Polimorfismo en Java
  6. Gráficos 2D en Java
  7. 3 diferentes tipos de matrices en PHP (ejemplos)