Clase y método abstractos de C#

En este tutorial, aprenderemos sobre la clase y el método abstractos de C# con la ayuda de ejemplos.

Clase abstracta

En C#, no podemos crear objetos de una clase abstracta. Usamos el abstract palabra clave para crear una clase abstracta. Por ejemplo,

// create an abstract class
abstract class Language {
  // fields and methods
}
...

// try to create an object Language
// throws an error
Language obj = new Language();

Una clase abstracta puede tener métodos abstractos (método sin cuerpo) y métodos no abstractos (método con cuerpo). Por ejemplo,

abstract class Language {

  // abstract method
  public abstract void display1();

  // non-abstract method
  public void display2() {
    Console.WriteLine("Non abstract method");
  }
}

Antes de seguir adelante, asegúrese de conocer la herencia de C#.

Clase abstracta heredada

Como no podemos crear objetos de una clase abstracta, debemos crear una clase derivada de ella. Para que podamos acceder a los miembros de la clase abstracta usando el objeto de la clase derivada. Por ejemplo,

using System;
namespace AbstractClass {

  abstract class Language {

    // non-abstract method
    public void display() {
      Console.WriteLine("Non abstract method");
    }
  }

  // inheriting from abstract class
  class Program : Language {

    static void Main (string [] args) {
      
      // object of Program class
      Program obj = new Program();

      // access method of an abstract class
      obj.display();

      Console.ReadLine();
    }
  }
}

Salida

Non abstract method

En el ejemplo anterior, hemos creado una clase abstracta llamada Idioma . La clase contiene un método no abstracto display() .

Hemos creado el Programa clase que hereda la clase abstracta. Note la declaración,

obj.display();

Aquí, obj es el objeto de la clase derivada Program . Estamos llamando al método de la clase abstracta usando el objeto obj .

Nota :Podemos usar la clase abstracta solo como clase base. Esta es la razón por la cual las clases abstractas no se pueden sellar. Para obtener más información, visite la clase y el método sellados de C#.

Método abstracto de C#

Un método que no tiene cuerpo se conoce como método abstracto. Usamos el abstract palabra clave para crear métodos abstractos. Por ejemplo,

public abstract void display();

Aquí, mostrar() es un método abstracto. Un método abstracto solo puede estar presente dentro de una clase abstracta.

Cuando una clase no abstracta hereda una clase abstracta, debe proporcionar una implementación de los métodos abstractos.

Ejemplo:Implementación del método abstracto

using System;
namespace AbstractClass {

  abstract class Animal {

    // abstract method
    public abstract void makeSound();
  }

  // inheriting from abstract class
  class Dog : Animal {

    // provide implementation of abstract method
    public override void makeSound() {

      Console.WriteLine("Bark Bark");

    }
  }
  class Program  {
    static void Main (string [] args) {
      // create an object of Dog class
      Dog obj = new Dog();
      obj.makeSound();    

      Console.ReadLine(); 
    }
  }
}

Salida

Bark Bark

En el ejemplo anterior, hemos creado una clase abstracta llamada Animal . Tenemos un método abstracto makeSound() dentro de la clase.

Tenemos un Perro clase que hereda del Animal clase. Perro class proporciona la implementación del método abstracto makeSound() .

// provide implementation of abstract method
public override void makeSound() {

  Console.WriteLine("Bark Bark");

}

Aviso, hemos usado override con hacerSonido() método. Esto indica que el método está anulando el método de la clase base.

Luego usamos el objeto del Perro clase para acceder a makeSound() .

Si el Perro class no había proporcionado la implementación del método abstracto makeSound() , Perro la clase también debería haberse marcado como abstracta.

Nota :A diferencia de la herencia de C#, no podemos usar virtual con los métodos abstractos de la clase base. Esto se debe a que una clase abstracta es implícitamente virtual.

Clase abstracta con descriptores de acceso get y set

Podemos marcar los accesores get y set como abstractos. Por ejemplo,

using System;
namespace AbstractClass {
  abstract class Animal {
    
    protected string name;
    // abstract method
    public abstract string Name {
      get;
      set;
    }
  }

  // inheriting from abstract class
  class Dog : Animal {

    // provide implementation of abstract method
    public override string Name {
      get {
        return name;
      }
      set {
        name = value; 
      }
    }
   
  }
  class Program  {
    static void Main (string [] args) {
      // create an object of Dog class
      Dog obj = new Dog();  
      obj.Name = "Tom";
      Console.WriteLine("Name: " + obj.Name); 

      Console.ReadLine();
    }
  }
}

Salida

Name: Tom

En el ejemplo anterior, hemos marcado el descriptor de acceso get y set como abstracto.

obj.Name = "Tom";
Console.WriteLine("Name: " + obj.Name);

Estamos configurando y obteniendo el valor del nombre campo de la clase abstracta Animal usando el objeto de la clase derivada Dog .

Acceso al Constructor de Clases Abstractas

Una clase abstracta también puede tener constructores. Por ejemplo,

using System;
namespace AbstractClass {
  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) {
      // create an object of Dog class
      Dog d1 = new Dog();  

      Console.ReadLine();
    }
  }
}

Salida

Animal Constructor
Dog Constructor

En el ejemplo anterior, hemos creado un constructor dentro de la clase abstracta Animal .

Dog d1 = new Dog();

Aquí, cuando creamos un objeto de la clase derivada Dog el constructor de la clase abstracta Animal también recibe una llamada.

Nota :También podemos usar destructores dentro de la clase abstracta.

Abstracción C#

Las clases abstractas se utilizan para lograr la abstracción en C#.

La abstracción es uno de los conceptos importantes de la programación orientada a objetos. Nos permite ocultar detalles innecesarios y mostrar solo la información necesaria.

Esto nos ayuda a gestionar la complejidad al ocultar detalles con una idea más simple y de mayor nivel.

Un ejemplo práctico de abstracción pueden ser los frenos de las motos. Sabemos lo que hace un freno. Cuando aplicamos el freno, la moto se detendrá. Sin embargo, el funcionamiento del freno se mantiene oculto para nosotros.

La principal ventaja de ocultar el funcionamiento del freno es que ahora el fabricante puede implementar los frenos de manera diferente para diferentes motos. Sin embargo, lo que hace el freno será lo mismo.

Ejemplo:Abstracción C#

using System;
namespace AbstractClass {
  abstract class MotorBike {
    
    public abstract void brake();
  }

  class SportsBike : MotorBike {

    // provide implementation of abstract method
    public override void brake() {
      Console.WriteLine("Sports Bike Brake");
    }
   
  }

  class MountainBike : MotorBike {

    // provide implementation of abstract method
    public override void brake() {      
      Console.WriteLine("Mountain Bike Brake");
    }
   
  }
  class Program  {
    static void Main (string [] args) {
      // create an object of SportsBike class
      SportsBike s1 = new SportsBike();  
      s1.brake();

      // create an object of MountainBike class
      MountainBike m1 = new MountainBike();
      m1.brake();

      Console.ReadLine();
    }
  }
}

Salida

Sports Bike Brake
Mountain Bike Brake

En el ejemplo anterior, hemos creado una clase abstracta MotorBike . Tiene un método abstracto brake() .

Como freno() es un método abstracto la implementación de brake() en Moto se mantiene oculto.

Cada moto tiene una implementación diferente del freno. Por eso SportsBike hace su propia implementación de brake() y Bicicleta de Montaña hace su propia implementación de brake() .

Nota :Usamos interfaces para lograr una abstracción completa en C#. Para obtener más información, visite la interfaz de C#.

Herencia de C# Clase anidada de C#

Lenguaje C