Composição de Interfaces

Parte da seção Programação Orientada a Objetos do Journey de GO da Coddy. Lição 31 de 107.

Go permite criar interfaces maiores compondo interfaces menores. Em vez de definir uma única interface grande com muitos métodos, você incorpora interfaces existentes dentro da definição de uma nova interface.

type Reader interface {
    Read() string
}

type Writer interface {
    Write(data string)
}

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

A interface ReadWriter agora exige os métodos Read() e Write(). Qualquer tipo que implemente ambos os métodos satisfaz ReadWriter, assim como Reader e 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 satisfaz ReadWriter
}

Essa abordagem de composição mantém as interfaces pequenas e focadas. Você pode misturá-las e combiná-las conforme necessário, criando contratos precisos para suas funções. A biblioteca padrão do Go usa esse padrão extensivamente, como io.ReadWriter que combina io.Reader e io.Writer.

Desafio

Fácil

Vamos criar um sistema de reprodução de mídia que demonstra a composição de interfaces. Você criará interfaces pequenas e focadas e, em seguida, as combinará em uma interface composta mais poderosa que um único tipo pode satisfazer.

Você organizará seu código em dois arquivos:

media.go: defina três interfaces e uma struct que implemente todas elas:
- Uma interface Player com um método Play() string
- Uma interface Recorder com um método Record(content string) string
- Uma interface MediaDevice que compõe Player e Recorder
- Uma struct SmartDevice com um campo Name que implementa todos os métodos necessários
main.go: crie funções que demonstrem como o mesmo SmartDevice pode ser usado por meio de diferentes tipos de interface. Escreva três funções:
- UsePlayer, que aceita um Player e chama seu método Play
- UseRecorder, que aceita um Recorder e uma string de conteúdo e, em seguida, chama Record
- UseMediaDevice, que aceita um MediaDevice e uma string de conteúdo e, em seguida, chama Record e Play
Leia o nome do dispositivo e o conteúdo da entrada, crie um SmartDevice e demonstre seu uso por meio dos três tipos de interface.

As seguintes entradas serão fornecidas:

Linha 1: Nome do dispositivo
Linha 2: Conteúdo a ser gravado

Seus métodos devem retornar strings nestes formatos:

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

Por exemplo, dados MyPhone e voice memo, sua saída deverá ser:

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

As duas primeiras linhas mostram o dispositivo usado por meio das interfaces individuais (Player e Recorder). As duas últimas linhas mostram seu uso por meio da interface composta MediaDevice, que exige ambas as capacidades. Observe como seu único SmartDevice satisfaz todas as três interfaces porque possui os dois métodos necessários.

Experimente você mesmo

package main

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

// TODO: Implementar UsePlayer que aceita um Player e chama seu método Play
// Deve imprimir o resultado de Play()

// TODO: Implementar UseRecorder que aceita um Recorder e uma string content
// Deve imprimir o resultado de Record(content)

// TODO: Implementar UseMediaDevice que aceita um MediaDevice e uma string content
// Deve imprimir o resultado de Record(content) e depois Play()

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	
	scanner.Scan()
	deviceName := scanner.Text()
	
	scanner.Scan()
	content := scanner.Text()
	
	// TODO: Criar um SmartDevice com o nome fornecido
	
	// TODO: Usar o dispositivo através da interface Player
	
	// TODO: Usar o dispositivo através da interface Recorder
	
	// TODO: Usar o dispositivo através da interface MediaDevice
	
	_ = deviceName
	_ = content
	fmt.Println("Implement the solution")
}