Introducción a la anulación en C #

La anulación en C # es la reimplementación de un método de clase base en una clase derivada. En esto, el método de la clase base se anula en la clase secundaria. El método de clase derivada tiene el mismo nombre y firma que el método de clase base. La anulación es útil para lograr el polimorfismo de tiempo de ejecución.

Hay algunas palabras clave que se utilizan en la anulación de métodos.

1. Virtual: esta palabra clave se usa con una clase base que significa que el método de una clase base se puede anular.

public virtual void Method()
(
// implementation
)

2. Anular: esta palabra clave se usa con una clase derivada que significa que la clase derivada anula un método de una clase base.

public override void Method()
(
// implementation
)

3. Base: esta palabra clave se utiliza en una clase derivada para llamar al método de la clase base.

public override void Method()
(
base.Method();
// implementation
)

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

A continuación se muestra un ejemplo de cómo podemos implementar la anulación en C #.

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

En el ejemplo anterior, hay dos clases, una es clase base o clase padre y la otra es clase derivada o podemos decir, clase hija. Un método de clase base se deriva en la clase secundaria. En esto, el método en un padre es virtual, lo que significa que puede ser anulado por la clase secundaria. Anular en un elemento secundario significa que este método es el mismo que el método de la clase principal con la misma firma de método.

Tipos de anulación en C #

A continuación se muestran los ejemplos que muestran la anulación de varias palabras clave.

Ejemplo 1: sin palabras clave virtuales y de anulación

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Overriding
(
class Bird // base class
(
public void fly() // base class method
(
Console.WriteLine("Birds are flying");
)
)
class Peacock : Bird // derived class
(
public new void fly() // derived class method
(
Console.WriteLine("Peacock is flying");
)
)
class Program
(
// main method
static void Main(string() args)
(
Bird b = new Peacock();
b.fly();
Console.ReadLine();
)
)
)

En el ejemplo anterior, no se usa ninguna palabra clave en ambas bases ni en los métodos derivados.

También en el método principal, la referencia principal se usa para llamar al método secundario. Entonces, en este caso cuando no se usa una palabra clave, se llama al método padre en lugar de un método hijo. Entonces la salida será

Salida:

Ejemplo 2 (a) - Con palabras clave virtuales y de anulación

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Overriding
(
class Bird // base class
(
public virtual void fly() // base class method
(
Console.WriteLine("Birds are flying");
)
)
class Peacock : Bird // derived class
(
public override void fly() // derived class method
(
Console.WriteLine("Peacock is flying");
)
)
class Program
(
// main method
static void Main(string() args)
(
Bird b = new Peacock();
b.fly();
Console.ReadLine();
)
)
)

En este ejemplo, virtual se usa en la clase base, lo que significa que le da autoridad a la clase secundaria para implementar el método a su manera. En una clase derivada, se usa anulación, lo que significa que el método secundario es el método de anulación. Ambos métodos son iguales con el mismo nombre y la misma firma de método, pero la parte de implementación es diferente. También en este ejemplo, la referencia primaria se usa para llamar al método secundario. Pero como un padre es un método virtual, se llama primero al método hijo en lugar del método padre. Entonces la salida será

Salida:

Ejemplo 2 (b) - Palabras clave virtuales y de anulación

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Overriding
(
class Bird // base class
(
public virtual void fly() // base class method
(
Console.WriteLine("Birds are flying");
)
)
class Peacock : Bird // derived class
(
public override void fly() // derived class method
(
Console.WriteLine("Peacock is flying");
)
)
class Program
(
//main method
static void Main(string() args)
(
Peacock p = new Peacock();
p.fly();
Console.ReadLine();
)
)
)

Este ejemplo es el mismo que el anterior pero este método secundario se utiliza como referencia.

Salida:

Ejemplo 3 - Con palabra clave base

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Overriding
(
class Bird // base class
(
public virtual void fly() // base class method
(
Console.WriteLine("Birds are flying");
)
)
class Peacock : Bird // derived class
(
public override void fly() // derived class method
(
base.fly(); // base is use to call parent method
Console.WriteLine("Peacock is flying");
)
)
class Program
(
static void Main(string() args)
(
Peacock p = new Peacock();
p.fly();
Console.ReadLine();
)
)
)

En el ejemplo anterior, la base se usa en una clase derivada para llamar al método de la clase base. Entonces, en este método base se llama primero y luego el método derivado.

Salida:

Ejemplo 4 - Clases abstractas con anulación

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Overriding
(
abstract class Calculate
(
public abstract int sum();
)
class Values : Calculate // derived class
(
int val1;
int val2;
public Values(int a = 0, int b = 0)
(
val1 = a;
val2 = b;
)
public override int sum()
(
Console.WriteLine("sum of two values");
return (val1 + val2);
)
)
class Program
(
static void Main(string() args)
(
Values v = new Values(10, 20);
int a = v.sum();
Console.WriteLine(a);
Console.ReadLine();
)
)
)

En el ejemplo anterior, se usa un método abstracto. La clase derivada implementa una clase abstracta que contiene un método abstracto.

Salida:

Reglas para anulación de métodos

  • La firma del método de una clase derivada debe ser la misma que la de una clase base.
  • La anulación no es posible en la misma clase.
  • Los modificadores de acceso deben ser los mismos para los métodos virtuales y los métodos de anulación.
  • La palabra clave virtual se usa en el método de clase base y Override se usa en un método de clase derivado.
  • El método de la clase base no debe ser estático.

Conclusión

La anulación es útil en el polimorfismo de tiempo de ejecución. Permite que la clase derivada implemente un método de clase base a su manera. Entonces, la implementación del método es diferente de la clase derivada de su clase base. El método anulado puede ser virtual, anular o abstracto.

Artículos recomendados

Esta es una guía para anular en C #. Aquí discutimos cómo usar la anulación y las diferentes palabras clave para Anular en C # junto con los Ejemplos. También puede consultar nuestros otros artículos sugeridos:

  1. Manejo de excepciones en C #
  2. Matrices en C #
  3. Método de anulación en C #
  4. Variables en C #
  5. Modificadores de acceso en PHP
  6. Polimorfismo en Java
  7. Clases abstractas en JavaScript
  8. Ejemplos de esta palabra clave