La anulación de métodos en C# es similar a la función virtual en C++ . Method Overriding es una técnica que permite invocar funciones de otra clase (clase base) en la clase derivada. La creación de un método en la clase derivada con la misma firma que un método en la clase base se denomina anulación de métodos.
En palabras simples, Overriding es una función que permite que una subclase o clase secundaria proporcione una implementación específica de un método que ya proporciona una de sus superclases o clases principales. Cuando un método en una subclase tiene el mismo nombre, los mismos parámetros o firma y el mismo tipo de retorno (o subtipo) que un método en su superclase, entonces se dice que el método en la subclase anula el método en la superclase. clase. La anulación de métodos es una de las formas en que C# logra el polimorfismo en tiempo de ejecución (polimorfismo dinámico) .
El método que se anula mediante una declaración de anulación se denomina método base anulado. Un método de anulación es una nueva implementación de un miembro que se hereda de una clase base. El método base invalidado debe ser virtual, abstracto o invalidado.
Ejemplo:
class base_class
{
public void gfg();
}
class derived_class : base_class
{
public void gfg();
}
class Main_Method
{
static void Main()
{
derived_class d = new derived_class();
d.gfg();
}
}
Aquí, la clase base se hereda en la clase derivada y se anula el método gfg() que tiene la misma firma en ambas clases.
En C# podemos usar 3 tipos de palabras clave para la anulación de métodos:
- palabra clave virtual: este modificador o palabra clave se usa dentro del método de clase base. Se utiliza para modificar un método en la clase base para anular ese método en particular en la clase derivada.
- anular: este modificador o palabra clave se usa con el método de clase derivada. Se utiliza para modificar un método virtual o abstracto en una clase derivada que se presenta en la clase base.
class base_class
{
public virtual void gfg();
}
class derived_class : base_class
{
public override void gfg();
}
class Main_Method
{
static void Main()
{
derived_class d = new derived_class();
d.gfg();
base_class b = new derived_class();
b.gfg();
}
}
Aquí primero, d se refiere al objeto de la clase clase_derivada e invoca gfg() de la clase clase_derivada luego, b se refiere a la referencia de la clase base y contiene el objeto de la clase derivada e invoca gfg() de la clase derivado. Aquí el método gfg() toma permiso de la clase base para anular el método en la clase derivada.
Ejemplo 1: anulación de métodos sin utilizar modificadores virtuales y de anulación
C#
// C# program to demonstrate the method overriding
// without using 'virtual' and 'override' modifiers
using System;
// base class name 'baseClass'
class baseClass
{
public void show()
{
Console.WriteLine("Base class");
}
}
// derived class name 'derived'
// 'baseClass' inherit here
class derived : baseClass
{
// overriding
new public void show()
{
Console.WriteLine("Derived class");
}
}
class GFG {
// Main Method
public static void Main()
{
// 'obj' is the object of
// class 'baseClass'
baseClass obj = new baseClass();
// invokes the method 'show()'
// of class 'baseClass'
obj.show();
obj = new derived();
// it also invokes the method
// 'show()' of class 'baseClass'
obj.show();
}
}
Base class Base class
Explicación: En este programa, el objeto obj invoca la clase baseClass dos veces y llama al método show() de la clase baseClass . Para evitar este problema, utilizamos la palabra clave virtual y override.
Ejemplo 2: anulación de métodos utilizando modificadores virtuales y de anulación .
C#
// C# program to illustrate the use of
//'virtual' and 'override' modifiers
using System;
class baseClass {
// show() is 'virtual' here
public virtual void show()
{
Console.WriteLine("Base class");
}
}
// class 'baseClass' inherit
// class 'derived'
class derived : baseClass
{
//'show()' is 'override' here
public override void show()
{
Console.WriteLine("Derived class");
}
}
class GFG {
// Main Method
public static void Main()
{
baseClass obj;
// 'obj' is the object
// of class 'baseClass'
obj = new baseClass();
// it invokes 'show()'
// of class 'baseClass'
obj.show();
// the same object 'obj' is now
// the object of class 'derived'
obj = new derived();
// it invokes 'show()' of class 'derived'
// 'show()' of class 'derived' is overridden
// for 'override' modifier
obj.show();
}
}
Base class Derived class
- Palabra clave base: se utiliza para acceder a los miembros de la clase base desde la clase derivada. Básicamente solía acceder a constructores y métodos o funciones de la clase base. La palabra clave base no puede usarse dentro de un método estático. La palabra clave base especifica qué constructor de la clase base debe invocarse al crear las instancias de la clase derivada.
Uso de la palabra clave base :
- Llamar a métodos o funciones de la clase base desde la clase derivada.
- Llame al constructor internamente de la clase base en el momento de la herencia .
Ejemplo 1:
C#
// C# program to show the use of 'base'
// keyword in method overriding
using System;
// base class
public class web {
string name = "GeeksForGeeks";
// 'showdata()' is member method,
// declare as virtual
public virtual void showdata()
{
Console.WriteLine("Website Name: " + name);
}
}
// derived class
// class 'web' is inherits
// class 'stream'
class stream : web {
string s = "Computer Science";
//'showdata()' is overridden
// in derived class
public override void showdata()
{
// Calling 'showdata()' of base
// class using 'base' keyword
base.showdata();
Console.WriteLine("About: " + s);
}
}
class GFG {
// Main Method
static void Main()
{
// 'E' is object of class stream
// also works as object of
// class 'web'
stream E = new stream();
// it first invokes 'showdata()'
// of class 'web' then it invokes
// 'showdata()' of class 'stream'
E.showdata();
}
}
Website Name: GeeksForGeeks About: Computer Science
Ejemplo 2: cómo la palabra clave base especifica la llamada del constructor de clase base de la clase derivada cuando se crean instancias de clase derivada.
C#
// C# program to show how base keyword
// specifies the calling of base-class
// constructor from the derived class
// when derived class instances are created
using System;
// base class
public class clssA {
int n1, n2;
// default constructor
public clssA()
{
Console.WriteLine("Default Constructor Invoked");
}
// parameterized constructor
public clssA(int i, int j)
{
// construct values
n1 = i;
n2 = j;
Console.WriteLine("Parameterized Constructor Invoked");
Console.WriteLine("Invoked Values are: " + n1 + " and " + n2);
}
}
// derived class
public class DerivedClass : clssA
{
// This constructor will instantiate
// 'clssA()' [no argument constructor]
// using 'base' keyword
public DerivedClass() : base() { }
// This constructor will instantiate
// 'clssA(int i, int j)' [parameterized
// constructor] using 'base' keyword
public DerivedClass(int i, int j) : base(i, j) { }
// Main Method
static void Main()
{
// invoke no argument constructor
DerivedClass d1 = new DerivedClass();
Console.WriteLine();
// invoke parameterized constructor
DerivedClass d2 = new DerivedClass(10, 20);
}
}
Producción:
Default Constructor Invoked Parameterized Constructor Invoked Invoked Values are: 10 and 20
Ejemplo 3: muestra cómo la palabra clave base especifica el constructor de la clase base llamado desde la clase derivada y también la llamada de un método usando la palabra clave base desde la clase derivada.
C#
// C# program to show how 'base' keyword specifies
// the base-class constructor that called from
// derived class and also calling a method 'swap'
// from derived class using base keyword
using System;
// base class
public class clssA {
public int n1, n2;
// default constructor
public clssA()
{
Console.WriteLine("In clssA 'no argument constructor' invoked");
}
// parameterized constructor
public clssA(int i, int j)
{
// construct values
n1 = i;
n2 = j;
Console.WriteLine("in clssA 'parameterized constructor' invoked");
Console.WriteLine("the invoked values are " + n1 + " and " + n2);
Console.WriteLine();
}
public virtual void swap()
{
Console.WriteLine("swap function of base class(clssA) invoked");
Console.WriteLine("Before swap num1 = {0} and num2 = {1}", n1, n2);
// swapping
int t = n1;
n1 = n2;
n2 = t;
Console.WriteLine("After swap num1 = {0} and num2 = {1}", n1, n2);
}
}
// derived class
public class DerivedClass : clssA {
// This constructor will instantiate
// 'clssA' [no argument constructor]
// using 'base' keyword
public DerivedClass() : base() { }
// This constructor will instantiate
// 'clssA' [parameterized constructor]
// using 'base' keyword
public DerivedClass(int i, int j) : base(i, j) { }
public override void swap()
{
// it access the swap function of
// 'clssA' using 'base' keyword
base.swap();
Console.WriteLine();
Console.WriteLine("Swap function of derived class invoked");
Console.WriteLine("Before swap num1 = {0} and num2 = {1}", n1, n2);
// swapping
int t = n1;
n1 = n2;
n2 = t;
Console.WriteLine("After swap num1 = {0} and num2 = {1}", n1, n2);
}
// Main Method
static void Main()
{
// invoke no argument constructor
DerivedClass d1 = new DerivedClass();
Console.WriteLine();
// invoke parameterized constructor
DerivedClass d2 = new DerivedClass(10, 20);
// calling swap function
d2.swap();
}
}
Producción:
In clssA 'no argument constructor' invoked in clssA 'parameterized constructor' invoked the invoked values are 10 and 20 swap function of base class(clssA) invoked Before swap num1 = 10 and num2 = 20 After swap num1 = 20 and num2 = 10 Swap function of derived class invoked Before swap num1 = 20 and num2 = 10 After swap num1 = 10 and num2 = 20
Nota:
- La anulación de métodos solo es posible en clases derivadas. Porque un método se anula en la clase derivada de la clase base.
- No se puede anular un método no virtual o estático.
- Tanto el método de anulación como el método virtual deben tener el mismo modificador de nivel de acceso.
Publicación traducida automáticamente
Artículo escrito por SoumikMondal y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA