Introduzione alle interfacce

Fa parte della sezione Programmazione orientata agli oggetti del percorso GO di Coddy. Lezione 25 di 107.

Un'interfaccia in Go definisce un insieme di firme di metodi senza implementarli. Descrive cosa può fare un tipo, non come lo fa. Qualsiasi tipo che implementa tutti i metodi di un'interfaccia la soddisfa automaticamente.

Ecco come definisci un'interfaccia:

type Speaker interface {
    Speak() string
}

Questa interfaccia Speaker richiede che qualsiasi tipo che la implementi abbia un metodo Speak() che restituisca una stringa. Ora qualsiasi struct con questo metodo può essere usata ovunque sia previsto un Speaker.

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

Sia Dog sia Cat soddisfano l’interfaccia Speaker perché hanno entrambi un metodo Speak() con la firma corretta. Ora puoi scrivere funzioni che accettano qualsiasi Speaker:

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

func main() {
    dog := Dog{Name: "Buddy"}
    cat := Cat{Name: "Whiskers"}
    
    MakeSound(dog)  // Buddy dice woof!
    MakeSound(cat)  // Whiskers dice meow!
}

Le interfacce ti consentono di scrivere codice flessibile e riutilizzabile che funziona con qualsiasi tipo che soddisfi i requisiti dell'interfaccia, indipendentemente dall'implementazione sottostante.

Sfida

Facile

Costruiamo un sistema di descrizione dei veicoli che mostri come le interfacce consentano a tipi diversi di condividere un comportamento comune. Creerai un'interfaccia che può essere soddisfatta da più tipi di veicoli, poi la userai per descrivere qualsiasi veicolo in modo uniforme.

Organizzerai il codice in due file:

vehicles.go: definisci un'interfaccia Describer con un unico metodo Describe() string. Poi crea due struct che soddisfano questa interfaccia:
- Car con i campi Brand e Model (entrambi stringhe)
- Bicycle con i campi Type (stringa) e Gears (int)
Ogni struct dovrebbe avere un metodo Describe() che restituisce una stringa descrittiva del veicolo.
main.go: crea una funzione chiamata PrintDescription che accetta qualsiasi Describer e stampa il risultato della chiamata al suo metodo Describe(). Leggi le informazioni sui veicoli dall'input, crea sia un Car che un Bicycle e usa la tua funzione per stampare la descrizione di ciascuno.

Verranno forniti i seguenti input:

Riga 1: marca dell'auto
Riga 2: modello dell'auto
Riga 3: tipo di bicicletta
Riga 4: numero di marce (intero)

I tuoi metodi Describe() dovrebbero restituire stringhe nei seguenti formati:

Auto: [Brand] [Model]
Bicicletta: [Type] bike with [Gears] gears

Ad esempio, dati Toyota, Camry, Mountain e 21, l'output dovrebbe essere:

Toyota Camry
Mountain bike with 21 gears

L'intuizione chiave è che la tua funzione PrintDescription funziona con qualsiasi tipo che abbia un metodo Describe(). Non deve sapere se sta gestendo un'auto, una bicicletta o qualsiasi altro tipo di veicolo che potresti aggiungere in seguito.

Provalo tu

package main

import (
	"fmt"
)

// TODO: Crea una funzione PrintDescription che accetti qualsiasi Describer
// e stampi il risultato della chiamata al suo metodo Describe()

func main() {
	// Leggi l'input
	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: Crea una Car con la marca e il modello forniti in input

	// TODO: Crea una Bicycle con il tipo e il numero di marce forniti in input

	// TODO: Usa PrintDescription per stampare la descrizione dell'auto

	// TODO: Usa PrintDescription per stampare la descrizione della bicicletta
}