33-Abstracion en C#

Temas tratados en esta entrada

• Clases y etodos abstratos
• Interface
• Multiples interfaces

Clases y metodos abstratos

La abstracción es el proceso de ocultar ciertos detalles y mostrar solo la información esencial al usuario.

La abstracción se puede lograr con clases abstractas o interfaces

La palabra abstract se utiliza para clases y metodos

• Clase abstracta: es una clase restringida que no se puede usar para crear objetos (para acceder a ella, se debe heredar de otra clase).
• Método abstracto: solo se puede usar en una clase abstracta y no tiene cuerpo. El cuerpo es proporcionado por el clase derivada (heredada de).

Una clase abstracta puede tener métodos abstractos y regulares:

...

Ejemplo

 abstract class Animal 
{
  public abstract void animalSound();
  public void sleep() 
  {
    Console.WriteLine("Zzz");
  }
}

    

Del ejemplo anterior, no es posible crear un objeto de la clase Animal:

Animal myObj = new Animal()

Para acceder a la clase abstracta, se debe heredar de otra clase.

Convirtamos la clase Animal que usamos en el capítulo de Polimorfismo a una clase abstracta.

para heredar una clase se usa el simbolo de dos puntos(:), se debe usar el metodo override para anular el metodo de la clase base

Ejemplo

        // Clase abstracta
abstract class Animal
{
  //Método abstracto (no tiene cuerpo)
  public abstract void animalSound();
  // método habitual
  public void sleep()
  {
    Console.WriteLine("Zzz");
  }
}

// Clase derivada (heredada de Animal)
class Pig : Animal
{
  public override void animalSound()
  {
    // El cuerpo de animalSound() se proporciona aquí
    Console.WriteLine("El cerdo dice: wee wee");
  }
}

class Program
{
  static void Main(string[] args)
  {
    Pig myPig = new Pig(); // Crear un objeto de cerdo
    myPig.animalSound();  // Llamar al método abstracto
    myPig.sleep();  // Llame al método regular
  }
}
    

Para lograr la seguridad, oculte ciertos detalles y solo muestre los importantes detalles de un objeto.

Interfaces

Las interfaces son otra forma de logar la abstracion

Un interface es una clase completamente abstrata que solo puede contener metodos y propriedades abstratas

Ejemplo

// interface
interface Animal 
{
  void animalSound(); // método de interfaz (no tiene cuerpo)
  void run(); // método de interfaz (no tiene cuerpo)
}
    

Es de buena pratica inicial con letra mayuscula I el inicio de un interface

Por defecto, los miembros de una interfaz son abstract y public

Nota: Las interfaces pueden contener propiedades y métodos, pero no campos.

Para acceder a los métodos de interfaz, la interfaz debe estar "implementada" (un poco como heredado) por otra clase

Para implementar una interfaz, utilice los dos puntos (:)símbolo (al igual que con la herencia)

El cuerpo del método de interfaz es proporcionada por la clase "implement"

Tenga en cuenta que no tiene que usar el override palabra clave al implementar una interfaz:

Ejemplo

        // Interface
interface IAnimal 
{
  void animalSound(); // método de interfaz (no tiene cuerpo)
}

// Pig "implementa" la interfaz IAnimal
class Pig : IAnimal 
{
  public void animalSound() 
  {
    // El cuerpo de animalSound() se proporciona aquí
    Console.WriteLine("The pig says: wee wee");
  }
}

class Program 
{
  static void Main(string[] args) 
  {
    Pig myPig = new Pig();  // Crear un objeto Cerdo
    myPig.animalSound();
  }
}
    

• Al igual que las clases abstractas , las interfaces no se pueden usar para crear objetos (en el ejemplo anterior, no es posible crear un objeto "IAnimal" en la clase Programa)
• Los métodos de interfaz no tienen un cuerpo - el el cuerpo lo proporciona la clase "implement"
• En la implementación de una interfaz, debe anular todos sus métodos
• Las interfaces pueden contener propiedades y métodos, pero no campos/variables
• Los miembros de la interfaz son por defecto abstracty public
• Una interfaz no puede contener un constructor (ya que no se puede usar para crear objetos)

Para lograr la seguridad, oculte ciertos detalles y solo muestre los importantes detalles de un objeto (interfaz).

C# no admite "herencia múltiple" (una clase solo puede heredar de una clase básica). Sin embargo, se puede lograr con interfaces, porque la clase puede implementar múltiples interfaces. Nota: Para implementar múltiples interfaces, sepárelas con una coma (vea el ejemplo a continuación).

---

Múltiples interfaces

Para implementar multiples interfaces se deben separar por comas

Ejemplo

        interface IFirstInterface 
{
  void myMethod(); // interface method
}

interface ISecondInterface 
{
  void myOtherMethod(); // interface method
}

// Implementar múltiples interfaces
class DemoClass : IFirstInterface, ISecondInterface 
{
  public void myMethod() 
  {
    Console.WriteLine("Some text..");
  }
  public void myOtherMethod() 
  {
    Console.WriteLine("Some other text...");
  }
}

class Program 
{
  static void Main(string[] args)
  {
    DemoClass myObj = new DemoClass();
    myObj.myMethod();
    myObj.myOtherMethod();
  }
}
    

---

Ir al indice