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

Interfaces

Siguiente ►
►

En Dart, las interfaces son una herramienta poderosa que permite definir contratos que las clases pueden implementar. A diferencia de algunos otros lenguajes de programación, Dart no tiene una palabra clave específica para definir interfaces. En su lugar, cualquier clase puede actuar como una interfaz.

Conceptos Clave

  1. Definición de Interfaces: En Dart, cualquier clase puede ser utilizada como una interfaz.
  2. Implementación de Interfaces: Las clases pueden implementar múltiples interfaces.
  3. Métodos y Propiedades: Las interfaces pueden definir métodos y propiedades que las clases deben implementar.

Definición de Interfaces

En Dart, una interfaz se define simplemente creando una clase con métodos y propiedades que otras clases deben implementar. Aquí hay un ejemplo básico:

class Animal {
  void makeSound();
}

En este ejemplo, Animal actúa como una interfaz que define un método makeSound.

Implementación de Interfaces

Para implementar una interfaz, una clase debe usar la palabra clave implements y proporcionar implementaciones para todos los métodos y propiedades definidos en la interfaz. Aquí hay un ejemplo:

class Dog implements Animal {
  @override
  void makeSound() {
    print('Woof!');
  }
}

En este ejemplo, Dog implementa la interfaz Animal y proporciona una implementación para el método makeSound.

Ejemplo Práctico

Vamos a ver un ejemplo más completo que incluye múltiples interfaces y clases que las implementan.

// Definición de interfaces
class Animal {
  void makeSound();
}

class Pet {
  void play();
}

// Implementación de interfaces
class Dog implements Animal, Pet {
  @override
  void makeSound() {
    print('Woof!');
  }

  @override
  void play() {
    print('The dog is playing.');
  }
}

class Cat implements Animal, Pet {
  @override
  void makeSound() {
    print('Meow!');
  }

  @override
  void play() {
    print('The cat is playing.');
  }
}

void main() {
  Dog dog = Dog();
  dog.makeSound(); // Output: Woof!
  dog.play(); // Output: The dog is playing.

  Cat cat = Cat();
  cat.makeSound(); // Output: Meow!
  cat.play(); // Output: The cat is playing.
}

En este ejemplo, Dog y Cat implementan las interfaces Animal y Pet, proporcionando sus propias implementaciones para los métodos makeSound y play.

Ejercicio Práctico

Ejercicio 1

Define una interfaz Vehicle con los métodos startEngine y stopEngine. Luego, crea dos clases Car y Bike que implementen esta interfaz.

Solución

// Definición de la interfaz
class Vehicle {
  void startEngine();
  void stopEngine();
}

// Implementación de la interfaz
class Car implements Vehicle {
  @override
  void startEngine() {
    print('Car engine started.');
  }

  @override
  void stopEngine() {
    print('Car engine stopped.');
  }
}

class Bike implements Vehicle {
  @override
  void startEngine() {
    print('Bike engine started.');
  }

  @override
  void stopEngine() {
    print('Bike engine stopped.');
  }
}

void main() {
  Car car = Car();
  car.startEngine(); // Output: Car engine started.
  car.stopEngine(); // Output: Car engine stopped.

  Bike bike = Bike();
  bike.startEngine(); // Output: Bike engine started.
  bike.stopEngine(); // Output: Bike engine stopped.
}

Ejercicio 2

Define una interfaz Shape con un método area. Luego, crea dos clases Circle y Rectangle que implementen esta interfaz y calculen el área correspondiente.

Solución

// Definición de la interfaz
class Shape {
  double area();
}

// Implementación de la interfaz
class Circle implements Shape {
  double radius;

  Circle(this.radius);

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

class Rectangle implements Shape {
  double width;
  double height;

  Rectangle(this.width, this.height);

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

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

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

Resumen

En esta sección, hemos aprendido sobre las interfaces en Dart, cómo definirlas y cómo implementarlas en clases. Las interfaces son una herramienta esencial para definir contratos en tu código, asegurando que las clases que implementan estas interfaces proporcionen las funcionalidades esperadas. Con estos conocimientos, estás preparado para utilizar interfaces en tus propios proyectos y mejorar la estructura y la mantenibilidad de tu código.

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