Composición de interfaces

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

Go te permite construir interfaces más grandes componiendo otras más pequeñas. En lugar de definir una interfaz grande con muchos métodos, incrustas interfaces existentes dentro de una nueva definición de interfaz.

type Reader interface {
    Read() string
}

type Writer interface {
    Write(data string)
}

// ReadWriter combina ambas interfaces
type ReadWriter interface {
    Reader
    Writer
}

La interfaz ReadWriter ahora requiere los métodos Read() y Write(). Cualquier tipo que implemente ambos métodos satisface ReadWriter, así como Reader y Writer individualmente.

type File struct {
    Name string
}

func (f File) Read() string       { return "file content" }
func (f File) Write(data string)  { fmt.Println("Writing:", data) }

func Process(rw ReadWriter) {
    content := rw.Read()
    rw.Write(content)
}

func main() {
    f := File{Name: "data.txt"}
    Process(f)  // File satisface ReadWriter
}

Este enfoque de composición mantiene las interfaces pequeñas y enfocadas. Puedes combinarlas según sea necesario, creando contratos precisos para tus funciones. La biblioteca estándar de Go utiliza este patrón extensamente, como io.ReadWriter, que combina io.Reader e io.Writer.

Desafío

Fácil

Construyamos un sistema de reproductor multimedia que demuestre la composición de interfaces. Crearás interfaces pequeñas y específicas, y después las combinarás en una interfaz compuesta más potente que un único tipo puede satisfacer.

Organizarás tu código en dos archivos:

media.go: Define tres interfaces y una estructura que las implementa todas:
- Una interfaz Player con un método Play() string
- Una interfaz Recorder con un método Record(content string) string
- Una interfaz MediaDevice que compone tanto Player como Recorder
- Una estructura SmartDevice con un campo Name que implementa todos los métodos requeridos
main.go: Crea funciones que demuestren cómo se puede usar el mismo SmartDevice mediante diferentes tipos de interfaz. Escribe tres funciones:
- UsePlayer, que acepta un Player y llama a su método Play
- UseRecorder, que acepta un Recorder y una cadena de contenido, y después llama a Record
- UseMediaDevice, que acepta un MediaDevice y una cadena de contenido, y después llama tanto a Record como a Play
Lee el nombre del dispositivo y el contenido de la entrada, crea un SmartDevice y demuestra cómo usarlo mediante los tres tipos de interfaz.

Se proporcionarán las siguientes entradas:

Línea 1: Nombre del dispositivo
Línea 2: Contenido que se grabará

Tus métodos deben devolver cadenas con estos formatos:

Play(): [Name] is playing
Record(content): [Name] recorded: [content]

Por ejemplo, dadas las entradas MyPhone y voice memo, tu salida debería ser:

MyPhone is playing
MyPhone recorded: voice memo
MyPhone recorded: voice memo
MyPhone is playing

Las dos primeras líneas muestran el dispositivo utilizado mediante las interfaces individuales (Player y Recorder). Las dos últimas líneas muestran su uso mediante la interfaz compuesta MediaDevice, que requiere ambas capacidades. Observa cómo tu único SmartDevice satisface las tres interfaces porque tiene ambos métodos requeridos.

Pruébalo tú mismo

package main

import (
	"bufio"
	"fmt"
	"os"
)

// TODO: Implementar UsePlayer que acepte un Player y llame a su método Play
// Debería imprimir el resultado de Play()

// TODO: Implementar UseRecorder que acepte un Recorder y una cadena content
// Debería imprimir el resultado de Record(content)

// TODO: Implementar UseMediaDevice que acepte un MediaDevice y una cadena content
// Debería imprimir el resultado de Record(content) y luego Play()

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	
	scanner.Scan()
	deviceName := scanner.Text()
	
	scanner.Scan()
	content := scanner.Text()
	
	// TODO: Crear un SmartDevice con el nombre dado
	
	// TODO: Usar el dispositivo a través de la interfaz Player
	
	// TODO: Usar el dispositivo a través de la interfaz Recorder
	
	// TODO: Usar el dispositivo a través de la interfaz MediaDevice
	
	_ = deviceName
	_ = content
	fmt.Println("Implement the solution")
}