Introdução às Interfaces

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

Uma interface em Go define um conjunto de assinaturas de métodos sem implementá-los. Ela descreve o que um tipo pode fazer, não como ele faz isso. Qualquer tipo que implemente todos os métodos de uma interface satisfaz automaticamente essa interface.

Veja como você define uma interface:

type Speaker interface {
    Speak() string
}

Essa interface Speaker exige que qualquer tipo que a implemente tenha um método Speak() que retorne uma string. Agora, qualquer struct com esse método pode ser usada onde quer que uma Speaker seja esperada.

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 quanto Cat satisfazem a interface Speaker porque cada um deles possui um método Speak() com a assinatura correta. Agora você pode escrever funções que aceitam qualquer Speaker:

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

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

As interfaces permitem escrever código flexível e reutilizável que funciona com qualquer tipo que atenda aos requisitos da interface, independentemente da implementação subjacente.

Desafio

Fácil

Vamos criar um sistema de descrição de veículos que demonstra como as interfaces permitem que diferentes tipos compartilhem um comportamento comum. Você criará uma interface que vários tipos de veículos podem implementar e, em seguida, a usará para descrever qualquer veículo de maneira uniforme.

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

vehicles.go: Defina uma interface Describer com um único método Describe() string. Em seguida, crie duas structs que implementem essa interface:
- Car com os campos Brand e Model (ambos strings)
- Bicycle com os campos Type (string) e Gears (int)
Cada struct deve ter um método Describe() que retorne uma string descritiva sobre o veículo.
main.go: Crie uma função chamada PrintDescription que aceite qualquer Describer e imprima o resultado da chamada do método Describe(). Leia as informações dos veículos da entrada, crie um Car e um Bicycle e use sua função para imprimir as descrições de cada um.

As seguintes entradas serão fornecidas:

Linha 1: marca do Car
Linha 2: modelo do Car
Linha 3: tipo do Bicycle
Linha 4: número de marchas (inteiro)

Seus métodos Describe() devem retornar strings nestes formatos:

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

Por exemplo, dadas as entradas Toyota, Camry, Mountain e 21, sua saída deve ser:

Toyota Camry
Mountain bike with 21 gears

A principal ideia é que sua função PrintDescription funcione com qualquer tipo que tenha um método Describe(). Ela não precisa saber se está lidando com um Car, um Bicycle ou qualquer outro tipo de veículo que você possa adicionar posteriormente.

Experimente você mesmo

package main

import (
	"fmt"
)

// TODO: Crie uma função PrintDescription que aceite qualquer Describer
// e imprima o resultado da chamada do seu método Describe()

func main() {
	// Ler 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: Crie um Car com a marca e o modelo da entrada

	// TODO: Crie um Bicycle com o tipo e as marchas da entrada

	// TODO: Use PrintDescription para imprimir a descrição do carro

	// TODO: Use PrintDescription para imprimir a descrição da bicicleta
}