Introducción a las interfaces

Parte de la sección Programación Orientada a Objetos del Journey de GO de Coddy. Lección 25 de 107.

Una interfaz en Go define un conjunto de firmas de métodos sin implementarlas. Describe lo que un tipo puede hacer, no cómo lo hace. Cualquier tipo que implemente todos los métodos de una interfaz satisface automáticamente esa interfaz.

Así es como defines una interfaz:

type Speaker interface {
    Speak() string
}

Esta interfaz Speaker requiere que any tipo que la implemente tenga un método Speak() que devuelva una cadena. Ahora, cualquier estructura con este método puede utilizarse donde se espere un Speaker.

type Dog struct {
    Name string
}

func (d Dog) Speak() string {
    return d.Name + " says woof!"
}

type Cat struct {
    Name string
}

func (c Cat) Speak() string {
    return c.Name + " says meow!"
}

Tanto Dog como Cat satisfacen la interfaz Speaker porque cada uno tiene un método Speak() con la firma correcta. Ahora puedes escribir funciones que acepten cualquier Speaker:

func MakeSound(s Speaker) {
    fmt.Println(s.Speak())
}

func main() {
    dog := Dog{Name: "Buddy"}
    cat := Cat{Name: "Whiskers"}
    
    MakeSound(dog)  // ¡Buddy dice guau!
    MakeSound(cat)  // ¡Whiskers dice miau!
}

Las interfaces te permiten escribir código flexible y reutilizable que funciona con cualquier tipo que cumpla los requisitos de la interfaz, independientemente de la implementación subyacente.

Desafío

Fácil

Construyamos un sistema de descripción de vehículos que demuestre cómo las interfaces permiten que distintos tipos compartan un comportamiento común. Crearás una interfaz que varios tipos de vehículos puedan satisfacer y, después, la usarás para describir cualquier vehículo de manera uniforme.

Organizarás tu código en dos archivos:

vehicles.go: Define una interfaz Describer con un único método Describe() string. Después, crea dos estructuras que satisfagan esta interfaz:
- Car con campos Brand y Model (ambos de tipo string)
- Bicycle con campos Type (string) y Gears (int)
Cada estructura debe tener un método Describe() que devuelva una cadena descriptiva sobre el vehículo.
main.go: Crea una función llamada PrintDescription que acepte cualquier Describer e imprima el resultado de llamar a su método Describe(). Lee la información de los vehículos desde la entrada, crea un Car y un Bicycle, y usa tu función para imprimir las descripciones de cada uno.

Se proporcionarán las siguientes entradas:

Línea 1: marca del Car
Línea 2: modelo del Car
Línea 3: tipo de Bicycle
Línea 4: número de cambios (entero)

Tus métodos Describe() deben devolver cadenas con estos formatos:

Car: [Brand] [Model]
Bicycle: [Type] bike with [Gears] gears

Por ejemplo, dadas las entradas Toyota, Camry, Mountain y 21, la salida debe ser:

Toyota Camry
Mountain bike with 21 gears

La idea clave es que tu función PrintDescription funciona con cualquier tipo que tenga un método Describe(). No necesita saber si está trabajando con un Car, un Bicycle o cualquier otro tipo de vehículo que puedas añadir más adelante.

Pruébalo tú mismo

package main

import (
	"fmt"
)

// TODO: Crea una función PrintDescription que acepte cualquier Describer
// e imprima el resultado de llamar a su método Describe()

func main() {
	// Leer la entrada
	var carBrand string
	var carModel string
	var bicycleType string
	var gears int

	fmt.Scanln(&carBrand)
	fmt.Scanln(&carModel)
	fmt.Scanln(&bicycleType)
	fmt.Scanln(&gears)

	// TODO: Crea un Car con la marca y el modelo de la entrada

	// TODO: Crea un Bicycle con el tipo y las marchas de la entrada

	// TODO: Usa PrintDescription para imprimir la descripción del coche

	// TODO: Usa PrintDescription para imprimir la descripción de la bicicleta
}