Dominando clases y métodos abstractos en C#: Guía práctica

Dominando clases y métodos abstractos en C#

Explora clases y métodos abstractos en C# a través de ejemplos claros, patrones de herencia, constructores y casos de uso reales.

Clase abstracta

En C#, las clases abstractas sirven como plantillas que no pueden instanciarse directamente. La palabra clave abstract indica que una clase está destinada a ser subclasificada. Por ejemplo:

// Define una clase abstracta
abstract class Language {
    // Campos y métodos
}
// Intentar crear una instancia lanza error
// Language obj = new Language();

Una clase abstracta puede contener tanto métodos abstractos (declaraciones sin cuerpo) como métodos concretos (totalmente implementados). Por ejemplo:

abstract class Language {
    // Método abstracto – sin cuerpo
    public abstract void Display();
    // Método concreto – tiene implementación
    public void DisplayInfo() {
        Console.WriteLine("Concrete method in abstract class");
    }
}

Antes de continuar, asegúrate de estar cómodo con conceptos de herencia en C#.

---

Heredando una clase abstracta

Como no puedes instanciar una clase abstracta directamente, debes crear una subclase concreta que derive de ella. La subclase hereda los miembros de la clase abstracta, permitiéndote usarlos a través del objeto derivado. Ejemplo:

using System;
namespace AbstractClassDemo {
    abstract class Language {
        public void Display() {
            Console.WriteLine("Concrete method in abstract class");
        }
    }
    // Subclase concreta
    class Program : Language {
        static void Main(string[] args) {
            Program prog = new Program();
            prog.Display();
            Console.ReadLine();
        }
    }
}

Salida

Concrete method in abstract class

En este ejemplo, Language es abstracta, mientras que Program hereda de ella y puede llamar a Display(). Observa que las clases abstractas no pueden ser sealed; siempre deben servir como tipos base.

Nota: Usa este patrón cuando necesites un contrato común que múltiples tipos derivados implementarán.

---

Métodos abstractos en C#

Un método abstracto declara una firma sin cuerpo. Obliga a las clases derivadas no abstractas a proporcionar una implementación. Por ejemplo:

public abstract void Display();

Solo las clases abstractas pueden contener métodos abstractos. Cuando una subclase concreta hereda tal clase, debe sobrescribir cada miembro abstracto a menos que se declare abstracta también.

Ejemplo: Implementando un método abstracto

using System;
namespace AbstractClassDemo {
    abstract class Animal {
        public abstract void MakeSound();
    }
    class Dog : Animal {
        public override void MakeSound() {
            Console.WriteLine("Bark Bark");
        }
    }
    class Program {
        static void Main(string[] args) {
            Dog dog = new Dog();
            dog.MakeSound();
            Console.ReadLine();
        }
    }
}

Salida

Bark Bark

Aquí, Animal declara un método abstracto MakeSound(). La subclase concreta Dog proporciona la sobrescritura, cumpliendo el contrato.

Nota: Los métodos abstractos son implícitamente virtual; por tanto, la palabra clave virtual es innecesaria y no permitida.

---

Propiedades abstractas con getters y setters

Los descriptores de acceso abstractos permiten a las clases derivadas proporcionar lógica personalizada para operaciones get y set de propiedades. Ejemplo:

using System;
namespace AbstractClassDemo {
    abstract class Animal {
        protected string name;
        public abstract string Name { get; set; }
    }
    class Dog : Animal {
        public override string Name {
            get { return name; }
            set { name = value; }
        }
    }
    class Program {
        static void Main(string[] args) {
            Dog dog = new Dog();
            dog.Name = "Tom";
            Console.WriteLine("Name: " + dog.Name);
            Console.ReadLine();
        }
    }
}

Salida

Name: Tom

La clase derivada implementa la propiedad abstracta, permitiendo gestión de estado encapsulado.

---

Constructores en clases abstractas

Las clases abstractas pueden definir constructores para inicializar estado compartido para todas las subclases. Cuando se crea una instancia de subclase, el constructor de la clase abstracta se ejecuta primero. Ejemplo:

using System;
namespace AbstractClassDemo {
    abstract class Animal {
        public Animal() {
            Console.WriteLine("Animal Constructor");
        }
    }
    class Dog : Animal {
        public Dog() {
            Console.WriteLine("Dog Constructor");
        }
    }
    class Program {
        static void Main(string[] args) {
            Dog d1 = new Dog();
            Console.ReadLine();
        }
    }
}

Salida

Animal Constructor
Dog Constructor

Las subclases también pueden definir destructores si se necesita lógica de limpieza.

Nota: Los constructores son útiles para configurar recursos comunes requeridos por todos los tipos derivados.

---

Abstracción en C# a través de clases abstractas

Las clases abstractas proporcionan un mecanismo para la abstracción: ocultan detalles de implementación mientras exponen una interfaz limpia. Esto simplifica sistemas complejos enfocándose en "qué" en lugar de "cómo".

Considera una analogía del mundo real: sistemas de frenos en motocicletas. El comportamiento externo del freno —reducir velocidad o detener la moto— es consistente, pero el mecanismo subyacente varía entre modelos. Las clases abstractas permiten a cada modelo implementar su lógica de frenado única sin alterar el contrato externo.

Ejemplo: Frenos de motocicleta

using System;
namespace AbstractClassDemo {
    abstract class MotorBike {
        public abstract void Brake();
    }
    class SportsBike : MotorBike {
        public override void Brake() {
            Console.WriteLine("Sports Bike Brake");
        }
    }
    class MountainBike : MotorBike {
        public override void Brake() {
            Console.WriteLine("Mountain Bike Brake");
        }
    }
    class Program {
        static void Main(string[] args) {
            SportsBike s1 = new SportsBike();
            s1.Brake();
            MountainBike m1 = new MountainBike();
            m1.Brake();
            Console.ReadLine();
        }
    }
}

Salida

Sports Bike Brake
Mountain Bike Brake

Aquí, MotorBike declara un método abstracto Brake(). Cada clase de moto concreta suministra su implementación específica, demostrando polimorfismo.

Nota: Para abstracción completa —sin implementación base en absoluto— considera usar interfaces en su lugar.