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 que você construa interfaces maiores ao compor interfaces menores. Em vez de definir uma única interface grande com muitos métodos, você incorpora interfaces existentes dentro de uma nova definição de 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 ambos 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 construir um sistema de player 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 implementa 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 tanto Player quanto 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 através 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, então chama Record
- UseMediaDevice que aceita um MediaDevice e uma string de conteúdo, então chama tanto Record quanto Play
Leia o nome do dispositivo e o conteúdo da entrada, crie um SmartDevice e demonstre o uso dele através dos três tipos de interface.

As seguintes entradas serão fornecidas:

Linha 1: Nome do dispositivo
Linha 2: Conteúdo para gravar

Seus métodos devem retornar strings nestes formatos:

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

Por exemplo, dado MyPhone e voice memo, sua saída deve ser:

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

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

Folha de consulta

Go permite que você construa interfaces maiores ao compor interfaces menores, incorporando interfaces existentes dentro de uma nova definição de interface:

type Reader interface {
    Read() string
}

type Writer interface {
    Write(data string)
}

// ReadWriter combines both interfaces
type ReadWriter interface {
    Reader
    Writer
}

Qualquer tipo que implemente todos os métodos das interfaces incorporadas satisfaz a interface composta:

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 satisfies ReadWriter
}

Um tipo que implementa uma interface composta também satisfaz cada uma das interfaces incorporadas individualmente. Essa abordagem de composição mantém as interfaces pequenas e focadas, permitindo que você crie contratos precisos para suas funções.

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")
}