El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Clases Abstractas

Siguiente ►
►

Las clases abstractas en Dart son una herramienta poderosa en la programación orientada a objetos. Permiten definir una estructura base que otras clases pueden heredar, pero no pueden ser instanciadas directamente. Esto es útil cuando deseas crear una clase que solo sirva como modelo para otras clases.

Conceptos Clave

  1. Definición de Clases Abstractas: Una clase abstracta se define utilizando la palabra clave abstract.
  2. Métodos Abstractos: Las clases abstractas pueden contener métodos abstractos, que son métodos sin implementación. Las subclases deben proporcionar la implementación de estos métodos.
  3. Herencia: Las clases abstractas se utilizan como base para otras clases que heredan de ellas.

Ejemplo Práctico

Definición de una Clase Abstracta

abstract class Animal {
  void makeSound(); // Método abstracto
  void move(); // Método abstracto
}

En este ejemplo, Animal es una clase abstracta con dos métodos abstractos: makeSound y move. No proporcionamos ninguna implementación para estos métodos.

Herencia de una Clase Abstracta

class Dog extends Animal {
  @override
  void makeSound() {
    print('Bark');
  }

  @override
  void move() {
    print('Run');
  }
}

class Bird extends Animal {
  @override
  void makeSound() {
    print('Chirp');
  }

  @override
  void move() {
    print('Fly');
  }
}

Aquí, Dog y Bird son clases que heredan de Animal y proporcionan implementaciones para los métodos abstractos makeSound y move.

Uso de Clases Abstractas

void main() {
  Animal dog = Dog();
  dog.makeSound(); // Output: Bark
  dog.move(); // Output: Run

  Animal bird = Bird();
  bird.makeSound(); // Output: Chirp
  bird.move(); // Output: Fly
}

En el main, creamos instancias de Dog y Bird y llamamos a sus métodos. Observa que no podemos crear una instancia de Animal directamente porque es una clase abstracta.

Ejercicio Práctico

Ejercicio 1: Crear una Clase Abstracta y Subclases

  1. Define una clase abstracta Shape con un método abstracto area.
  2. Crea dos subclases Circle y Rectangle que hereden de Shape.
  3. Implementa el método area en ambas subclases.

Solución

abstract class Shape {
  double area();
}

class Circle extends Shape {
  double radius;

  Circle(this.radius);

  @override
  double area() {
    return 3.14 * radius * radius;
  }
}

class Rectangle extends Shape {
  double width;
  double height;

  Rectangle(this.width, this.height);

  @override
  double area() {
    return width * height;
  }
}

void main() {
  Shape circle = Circle(5);
  print('Area of Circle: ${circle.area()}'); // Output: Area of Circle: 78.5

  Shape rectangle = Rectangle(4, 5);
  print('Area of Rectangle: ${rectangle.area()}'); // Output: Area of Rectangle: 20
}

Retroalimentación y Consejos

  • Errores Comunes:

    • Intentar instanciar una clase abstracta directamente.
    • Olvidar implementar todos los métodos abstractos en las subclases.

  • Consejos:

    • Utiliza clases abstractas para definir una interfaz común para un grupo de clases relacionadas.
    • Asegúrate de que todas las subclases proporcionen implementaciones para los métodos abstractos.

Conclusión

Las clases abstractas son fundamentales para la programación orientada a objetos en Dart. Permiten definir una estructura base que otras clases pueden heredar, asegurando que ciertas funcionalidades sean implementadas en las subclases. Esto facilita la creación de código más organizado y mantenible. En el próximo tema, exploraremos las interfaces y cómo se diferencian de las clases abstractas.

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados