Imagen por X F .

Overriding es la práctica de cambiar el método de una clase base en una clase derivada.

El resultado es que cuando invocamos el método, la versión más nueva o con más overrides se invoca.

Cuando trabajamos con jerarquías hereditarias, a menudo queremos usar versiones un poco diferentes de las funciones de clases base. Hacerlo es fácil. Simplemente tienes que recrear el método en la clase derivada y escribir lo que sea que necesite hacer.

Considera una situación en la que tenemos una clase base Humanoid, la misma que tiene una clase derivada Enemy, la cual a su vez tiene una clase derivada Orc.

La clase Humanoid tiene una función llamada Yell(). Cuando Humanoid invoca Yell() el modelo grita y pone las manos alrededor de su boca.

public class Humanoid
{
    public void Yell()
    {
        // Raise hands to mouth
        // Play "Yelling sound"
    }
}

El método Yell() es heredado automáticamente por la clase Enemy. Sin embargo, queremos modificarlo. Queremos que el enemigo atraiga a otros enemigos.

public class Enemy : Humanoid
{
    public void Yell()
    {
        // Attack nearby enemies
    }
}

También queremos que Orc pueda invocar esta función. Pero cuando Yell() se invoca desde un objeto Orc, todos los orcos en el área obtienen un bono en sus ataques por un período de tiempo corto. Lo que necesitamos hacer efectivamente es un override de la versión base del método Yell() en cada una de las clases derivadas.

public class Orc : Enemy
{
    public void Yell() // warning por falta de sobrescritura
    {
        // Power up nearby orcs
    }
}

Unity nos va a advertir cuando trates de hacer un override de un método base en una clase derivada.

Para evitar esa advertencia y decirle a Unity que efectivamente queríamos hacer un override del método usamos las palabras reservadas virtual y override. Estas palabras reservadas van antes del tipo de retorno del método.

El método en la clase base se define como virtual.

public class Humanoid
{
    public virtual void Yell()
    {
        // Raise hands to mouth
        // Play "Yelling sound"
    }
}

Y los métodos en todas las clases derivadas se definen como override

public class Enemy : Humanoid
{
    public override void Yell()
    {
        // Attack nearby enemies
    }
}

public class Orc : Enemy
{
    public override void Yell()
    {
        // Power up nearby orcs
    }
}

Cualquier método que se declara virtual puede tener un override originado por una clase derivada. Un uso más interesante del overriding sería si quieres que cada clase derivada añada una funcionalidad específica para un método sin perder la funcionalidad original que provee la clase base.

Para hacerlo, necesitas usar la palabra reservada base para invocar la versión base del método también. En nuestro ejemplo anterior, digamos que queremos que un Enemy mantenga la funcionalidad de Humanoid mientras añade su propio efecto. También queremos que Orc mantenga la funcionalidad de Enemy mientras agrega su propio efecto.

Para lograrlo, necesitamos poner una invocación base al método base Yell() en ambos Enemy y Orc.

public class Enemy : Humanoid
{
    public override void Yell()
    {
        base.Yell();
        Debug.Log("Call Humanoid Yell()");
        // Attack nearby enemies
    }
}

public class Orc : Enemy
{
    public override void Yell()
    {
        base.Yell();
        Debug.Log("Call Enemy Yell()");
        // Power up nearby orcs
    }
}

Ahora, cuando se invoca el método Orc Yell(), invocará el método de Enemy Yell(), el mismo que a su vez invocará el método de Humanoid Yell().

Overriding también es muy útil con polimorfismo.

Al declarar el método base como un método Yvirtual, y el método derivado como un override vamos a hacer un overrideoverride efectivo de la versión base del método. El resultado es que cuando ampliamos una referencia derivada a un objeto base y luego invocamos un método, la versión derivada de ese método se invocará.

Apoya el contenido de mi blog a través de:

Fuente:

• Microsoft Docs: Override C#
• Unity Learn: Junior Programer