Perché Go non ha l'ereditarietà

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

I linguaggi tradizionali orientati agli oggetti come Java e C++ usano l’ereditarietà per condividere il codice tra i tipi. Una classe figlia estende una classe genitore, ereditandone tutti i campi e i metodi. Go omette deliberatamente questa funzionalità.

L’ereditarietà crea un forte accoppiamento tra i tipi. Quando una classe genitore cambia, tutte le classi figlie ne risentono.

Le gerarchie di ereditarietà profonde diventano difficili da comprendere e mantenere. Il «problema della classe base fragile» si verifica quando le modifiche a una classe base compromettono inaspettatamente le classi derivate.

I progettisti di Go hanno scelto una strada diversa: composizione anziché ereditarietà. Invece di dire «un Dog è un Animal», Go ti incoraggia a dire «un Dog ha comportamenti simili a quelli di Animal». Questo sottile cambiamento porta a un codice più flessibile e manutenibile.

Go realizza il riutilizzo del codice attraverso due meccanismi che hai già imparato:

Le interfacce definiscono contratti di comportamento senza dettagli di implementazione

L’incorporamento di struct consente ai tipi di includere altri tipi e riutilizzarne i metodi

Considera questo confronto. Nella programmazione OOP tradizionale, potresti scrivere class Dog extends Animal. In Go, incorpori una struct Animal all'interno di Dog e implementi interfacce condivise. Il risultato è una funzionalità simile con un accoppiamento più debole tra i tipi.

Questo capitolo approfondisce l’incorporamento di struct, mostrando come Go ottenga i vantaggi dell’ereditarietà senza i suoi svantaggi.

Sfida

Facile

Creiamo un sistema di notifiche che dimostri l'approccio di Go basato sulla composizione anziché sull'ereditarietà. Creerai tipi che condividono comportamenti tramite interfacce e incorporamento di struct, anziché gerarchie di classi.

Organizzerai il codice in tre file:

notifier.go: Definisci un'interfaccia Notifier con un unico metodo Notify(message string) string. Crea anche una struct BaseNotifier con un campo Name che verrà incorporato da altri tipi. Aggiungi a BaseNotifier un metodo chiamato Format(message string) string che restituisce il messaggio preceduto dal nome del notificatore tra parentesi quadre.
channels.go: Crea due tipi di canale di notifica che incorporano BaseNotifier e implementano l'interfaccia Notifier:
- EmailNotifier con un campo aggiuntivo Address
- SMSNotifier con un campo aggiuntivo Phone
Il metodo Notify di ciascun tipo deve usare il metodo incorporato Format e includere nell'output le informazioni specifiche del canale.
main.go: Crea una funzione chiamata SendAlert che accetta qualsiasi Notifier e un messaggio, quindi restituisce il risultato della chiamata a Notify. Leggi i dettagli delle notifiche dall'input, crea entrambi i tipi di notificatori e mostra come possono essere usati in modo intercambiabile tramite l'interfaccia.

Verranno forniti i seguenti input:

Riga 1: Nome del notificatore per l'email
Riga 2: Indirizzo email
Riga 3: Nome del notificatore per SMS
Riga 4: Numero di telefono
Riga 5: Messaggio di avviso

Il metodo Format su BaseNotifier deve restituire:

[Name] message

I metodi Notify devono restituire:

EmailNotifier: Email to [Address]: [formatted message]
SMSNotifier: SMS to [Phone]: [formatted message]

Ad esempio, con Alerts, user@mail.com, Urgent, 555-1234 e Server down, l'output dovrebbe essere:

Email to user@mail.com: [Alerts] Server down
SMS to 555-1234: [Urgent] Server down

Nota come entrambi i tipi di notificatori riutilizzano il metodo Format di BaseNotifier tramite l'incorporamento, mentre ciascuno fornisce la propria implementazione di Notify. La funzione SendAlert funziona con qualsiasi Notifier senza conoscere il tipo concreto. Questa è la composizione al posto dell'ereditarietà in azione.

Provalo tu

package main

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

// SendAlert accetta un qualsiasi Notifier e un messaggio e restituisce il risultato della chiamata a Notify
// TODO: Implementa la funzione SendAlert

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	
	// Leggi il nome del notificatore email
	scanner.Scan()
	emailName := scanner.Text()
	
	// Leggi l'indirizzo email
	scanner.Scan()
	emailAddress := scanner.Text()
	
	// Leggi il nome del notificatore SMS
	scanner.Scan()
	smsName := scanner.Text()
	
	// Leggi il numero di telefono
	scanner.Scan()
	phoneNumber := scanner.Text()
	
	// Leggi il messaggio di avviso
	scanner.Scan()
	alertMessage := scanner.Text()
	
	// TODO: Crea un EmailNotifier con emailName e emailAddress
	
	// TODO: Crea un SMSNotifier con smsName e phoneNumber
	
	// TODO: Usa SendAlert per inviare alertMessage tramite entrambi i notificatori
	// e stampa i risultati
	
	// Evita gli avvisi relativi alle variabili non utilizzate (rimuovi queste istruzioni quando usi le variabili)
	_ = emailName
	_ = emailAddress
	_ = smsName
	_ = phoneNumber
	_ = alertMessage
}