Qual è la somiglianza e la differenza tra una classe normale e una classe astratta?

In Golang non esiste il concetto di "classe normale" e "classe astratta" nella forma in cui esistono in linguaggi orientati agli oggetti come Java o C#.

Tuttavia, la loro funzionalità può essere imitata utilizzando strutture e interfacce.

Somiglianze (usando strutture e interfacce in Golang):

• Stato (dati): La struttura può contenere campi, come una classe normale che memorizza proprietà.
• Comportamento (metodi): È possibile allegare metodi alla struttura, che definiranno il suo comportamento, simile ai metodi di una classe normale.
• Contratto comune (per classe astratta e interfaccia): L'interfaccia in Golang definisce un insieme di metodi che qualsiasi struttura "che implementa" questa interfaccia deve definire. Questo è simile a come una classe astratta o interfaccia in altri linguaggi definisce un contratto per le classi che ereditano o implementano.

Differenze (nel contesto di Golang):

Caratteristica	"Classe normale" (struttura con metodi)	"Classe astratta" (interfaccia + strutture)
Creazione diretta	È possibile creare un'istanza della struttura.	Non è possibile creare un'istanza dell'interfaccia.
Implementazione dei metodi	Tutti i metodi allegati alla struttura hanno implementazione.	L'interfaccia dichiara solo metodi, ma non la loro implementazione.
Ereditarietà	Non c'è ereditarietà esplicita nel senso classico. È possibile usare la composizione (inclusione di strutture).	L'interfaccia non eredita, ma viene implementata dalle strutture.
Obbligo di implementazione	Non c'è obbligo di implementare un insieme specifico di metodi, tranne quelli allegati alla struttura.	Qualsiasi struttura che "implementa" l'interfaccia Golang deve fornire l'implementazione di tutti i suoi metodi.
Memorizzazione dello stato (campi)	La struttura può contenere campi di dati.	L'interfaccia non contiene campi di dati.

Esempio di imitazione:

// interfaccia che imita una classe astratta
type Shape interface {
	Area() float64
	Perimeter() float64
}

// struttura che imita una classe normale
type Circle struct {
	Radius float64
}

// implementazione dei metodi dell'interfaccia per Circle
func (c Circle) Area() float64 {
	return 3.14 * c.Radius * c.Radius
}

func (c Circle) Perimeter() float64 {
	return 2 * 3.14 * c.Radius
}

// Un'altra struttura che implementa l'interfaccia
type Rectangle struct {
	Width, Height float64
}

func (r Rectangle) Area() float64 {
	return r.Width * r.Height
}

func (r Rectangle) Perimeter() float64 {
	return 2 * (r.Width + r.Height)
}

In questo esempio, Shape funge da contratto (simile a una classe astratta o interfaccia in altri linguaggi), e Circle e Rectangle sono implementazioni concrete (analoghi a classi normali). Possiamo creare istanze di Circle e Rectangle, ma non possiamo creare direttamente un'istanza di Shape. Inoltre, entrambe le strutture devono implementare i metodi Area() e Perimeter() per "rispettare" l'interfaccia Shape.