Incorporando Múltiplas Structs

Parte da seção Programação Orientada a Objetos do Journey de GO da Coddy — lição 37 de 107.

O Go permite que você incorpore múltiplas structs dentro de uma única struct, combinando comportamentos de diferentes fontes. Isso é semelhante à herança múltipla em outras linguagens, mas com a abordagem de composição do Go.

type Logger struct{}

func (l Logger) Log(msg string) string {
    return "LOG: " + msg
}

type Notifier struct{}

func (n Notifier) Notify(msg string) string {
    return "NOTIFY: " + msg
}

type Service struct {
    Name string
    Logger
    Notifier
}

A struct Service agora tem acesso a métodos de ambos os tipos incorporados:

func main() {
    s := Service{Name: "OrderService"}
    fmt.Println(s.Log("started"))      // LOG: started
    fmt.Println(s.Notify("new order")) // NOTIFY: new order
}

Ao incorporar múltiplas structs, um conflito de nomes pode ocorrer se dois tipos incorporados tiverem métodos com o mesmo nome. O Go não resolve automaticamente essa ambiguidade:

type A struct{}
func (A) Greet() string { return "Hello from A" }

type B struct{}
func (B) Greet() string { return "Hello from B" }

type Combined struct {
    A
    B
}

func main() {
    c := Combined{}
    // c.Greet() - erro de compilação: seletor ambíguo
    fmt.Println(c.A.Greet())  // Hello from A
    fmt.Println(c.B.Greet())  // Hello from B
}

Quando surgirem conflitos, você deve especificar explicitamente qual método do tipo incorporado deseja chamar, usando o nome do tipo como um qualificador.

Desafio

Fácil

Vamos construir um sistema de dispositivo doméstico inteligente que combina múltiplas capacidades através da incorporação de structs (struct embedding). Você criará um dispositivo que pode controlar a iluminação e reproduzir música ao incorporar tipos de controladores separados.

Você organizará seu código em três arquivos:

controllers.go: Crie duas structs de controladores independentes que fornecem capacidades diferentes:
- Um LightController com um campo Brightness (int) e um método SetLight(level int) string que retorna "Light set to [level]%"
- Um AudioController com um campo Volume (int) e um método SetVolume(level int) string que retorna "Volume set to [level]%"
Ambos os controladores também devem ter um método Status() string—isso cria um conflito de nomes que você precisará gerenciar. LightController.Status() deve retornar "Brightness: [Brightness]%" e AudioController.Status() deve retornar "Volume: [Volume]%".
device.go: Crie uma struct SmartDevice com um campo Name que incorpora tanto LightController quanto AudioController. Adicione um método chamado FullStatus() string que retorna o nome do dispositivo junto com os status de ambos os controladores, resolvendo a ambiguidade ao chamar explicitamente o método Status() de cada tipo incorporado.
main.go: Leia a configuração do dispositivo a partir da entrada, crie um SmartDevice, use os métodos promovidos para definir os níveis de luz e volume e, em seguida, exiba o status completo.

As seguintes entradas serão fornecidas:

Linha 1: Nome do dispositivo
Linha 2: Nível de brilho inicial (inteiro)
Linha 3: Nível de volume inicial (inteiro)
Linha 4: Novo nível de brilho a ser definido (inteiro)
Linha 5: Novo nível de volume a ser definido (inteiro)

Seu método FullStatus() deve retornar:

[Name] - [LightController.Status()], [AudioController.Status()]

Imprima os resultados da chamada de SetLight e SetVolume (que são promovidos dos tipos incorporados) e, em seguida, imprima o status completo.

Por exemplo, dados Living Room Hub, 50, 30, 75, e 60, sua saída deve ser:

Light set to 75%
Volume set to 60%
Living Room Hub - Brightness: 75%, Volume: 60%

Observe como SetLight e SetVolume são acessíveis diretamente em SmartDevice através da promoção de métodos, mas Status() requer qualificação explícita porque ambos os tipos incorporados possuem esse método.

Folha de consulta

Go permite a incorporação de múltiplas structs dentro de uma única struct, combinando comportamentos de diferentes fontes através de composição:

type Logger struct{}

func (l Logger) Log(msg string) string {
    return "LOG: " + msg
}

type Notifier struct{}

func (n Notifier) Notify(msg string) string {
    return "NOTIFY: " + msg
}

type Service struct {
    Name string
    Logger
    Notifier
}

A struct Service tem acesso aos métodos de ambos os tipos incorporados:

s := Service{Name: "OrderService"}
fmt.Println(s.Log("started"))      // LOG: started
fmt.Println(s.Notify("new order")) // NOTIFY: new order

Conflitos de nomenclatura ocorrem quando tipos incorporados possuem métodos com o mesmo nome. Você deve especificar explicitamente qual método do tipo incorporado chamar:

type A struct{}
func (A) Greet() string { return "Hello from A" }

type B struct{}
func (B) Greet() string { return "Hello from B" }

type Combined struct {
    A
    B
}

// c.Greet() - compile error: ambiguous selector
c := Combined{}
fmt.Println(c.A.Greet())  // Hello from A
fmt.Println(c.B.Greet())  // Hello from B

Experimente você mesmo

package main

import (
	"fmt"
)

func main() {
	// Ler entrada
	var name string
	fmt.Scanln(&name)

	var initialBrightness int
	fmt.Scanln(&initialBrightness)

	var initialVolume int
	fmt.Scanln(&initialVolume)

	var newBrightness int
	fmt.Scanln(&newBrightness)

	var newVolume int
	fmt.Scanln(&newVolume)

	// TODO: Criar um SmartDevice com o nome e valores iniciais fornecidos

	// TODO: Usar o método SetLight promovido e imprimir o resultado

	// TODO: Usar o método SetVolume promovido e imprimir o resultado

	// TODO: Imprimir o status completo usando o método FullStatus()
}