Modificador sealed en C#

Bienvenidos a este nuevo post, en el que hablaremos de dos piezas claves en la programación orientada a objetos, aunque no se utilizan demasiado, siempre esta bien tenerlas en cuenta.  

Además, ambas tienen mucho que ver, ya que utilizar sealed en una clase previene que podamos implementarla, y final evita que podamos sobrescribir métodos. 

1 - Qué es el modificador sealed 

Una sealed class o clase sellada es aquella de la cual no podemos heredar. Lo que quiere decir que no podemos implementara en otras clases para tener acceso a sus miembros. 

Lo más fácil es verlo con un ejemplo.

Si recordamos el ejemplo que vimos en la herencia con los vehículos, teníamos lo siguiente: 

class Vehiculo
{
    //Código
}

class Coche : Vehiculo 
{
//Código
}

class Moto : Vehiculo
{
//Código
}

Dentro de coche, podríamos incluir tanto furgoneta, como furgón, turismo, etc. 

class Furgoneta : Coche {}
class Furgon : Coche {}
class Turismo : Coche {}

Pero por la lógica de nuestro negocio podemos querer esta funcionalidad no suceda. Para ello podemos añadir el modificador sealed, el cual evitara que podamos heredar de ella. 

sealed class Coche : Vehiculo
{
    //Código
}

sealed class Moto : Vehiculo
{
    //Código
}

class Furgoneta : Coche { } //Error
class Furgon : Coche { } //Error
class Turismo : Coche { } //Error

Como vemos hemos añadido el modificador a la clase Coche, para que así, ninguna otra pueda heredar de ella. 

Como vemos en el ejemplo, la implementación de las clases Furgoneta, Furgon y Turismo nos da un error de que no pueden derivar de una clase sealed.

2 - Modificador sealed en métodos

Como recordamos del post sobre el polimorfismo en POO () podemos sobrescribir métodos en las clases que derivan de otra utilizando los modificadores virtual y override. 

class Vehiculo
{
    public decimal VelocidadMaxima { get; set; }
    public int NumeroRuedas { get; set; }
    public string Marca { get; set; }
    public string Modelo { get; set; }

    public Vehiculo(string marca, string modelo)
    {
        Marca = marca;
        Modelo = modelo;
    }
    public virtual void Acelerar()
    {
        Console.WriteLine("Acelerar vehículo");
        //Pisar el acelerador
    }

}

class Moto : Vehiculo
{
    public int Cilindrada { get; set; }

    public Moto(string marca, string modelo, int cilindrada) : base(marca, modelo)
    {
        Cilindrada = cilindrada;
    }

    public override void Acelerar()
    {
        //Girar el puño
        Console.WriteLine("Acelerar Moto");
    }
}

Además de ello, podemos incluir lo visto anteriormente con las clases, pero para métodos individuales. 

Cuando incluimos sealed en un método, quiere decir que ya no podemos seguir sobrescribiendo el método en las clases hijas. Con lo que cuando llamamos al método, será siempre el que hemos indicado como final. 

class Moto : Vehiculo
{
    public int Cilindrada { get; set; }

    public Moto(string marca, string modelo, int cilindrada) : base(marca, modelo)
    {
        Cilindrada = cilindrada;
    }

    public sealed override  void Acelerar()
    {
        //Girar el puño
        Console.WriteLine("Acelerar Moto");
    }
}
class Triciclo : Moto
{
    public Triciclo(string marca, string modelo, int cilindrada) : base(marca, modelo, cilindrada)
    {
    }

    public override void Acelerar() //Error
    {
        //Código
    }
}

Como vemos en el ejemplo hemos añadido el modificador sealed antes del override, lo que indica que desde ahí ya no se va a poder heredar ese método, y por ese motivo, en la clase que hereda de moto si intentamos crear un método llamado Acelerar() nos da un error, ya que el método de la clase padre esta sellado.