Wat is de overeenkomst en het verschil tussen een gewone en een abstracte klasse?

In Golang bestaat het concept van "gewoon klasse" en "abstracte klasse" niet zoals ze bestaan in objectgeoriënteerde talen zoals Java of C#.

Echter, hun functionaliteit kan worden geïmiteerd door structuren en interfaces te gebruiken.

Gelijkenissen (met structuren en interfaces in Golang):

• Toestand (gegevens): De structuur kan velden bevatten, zoals een gewone klasse eigenschappen opslaat.
• Gedrag (methoden): Methoden kunnen aan de structuur worden gekoppeld, die het gedrag bepalen, vergelijkbaar met methoden van een gewone klasse.
• Algemeen contract (voor abstracte klasse en interface): De interface in Golang definieert een set methoden die elke "implementerende" structuur moet implementeren. Dit lijkt op hoe een abstracte klasse of interface in andere talen een contract vastlegt voor afstammende of implementerende klassen.

Verschillen (in de context van Golang):

Kenmerk	"Gewone klasse" (structuur met methoden)	"Abstracte klasse" (interface + structuren)
Directe creatie	Een instantie van de structuur kan worden gemaakt.	Een instantie van de interface kan niet worden gemaakt.
Implementatie van methoden	Alle methoden gekoppeld aan de structuur hebben een implementatie.	De interface declareert alleen methoden, maar niet hun implementatie.
Erfelijkheid	Er is geen expliciete erfelijkheid in de klassieke zin. Structuurcompositie (inbedden van structuren) kan worden gebruikt.	De interface erft niet, maar wordt geïmplementeerd door structuren.
Verplichting tot implementatie	Er is geen verplichting om een bepaald set methoden te implementeren, behalve die gekoppeld aan de structuur.	Elke structuur die de Golang-interface "implementeert" moet alle methoden ervan implementeren.
Opslag van toestand (velden)	Structuur kan gegevensvelden bevatten.	De interface bevat geen gegevensvelden.

Voorbeeld van imitatie:

// interface die een abstracte klasse imiteert
type Shape interface {
	Area() float64
	Perimeter() float64
}

// structuur die een gewone klasse imiteert
type Circle struct {
	Radius float64
}

// implementatie van de interface-methoden voor Circle
func (c Circle) Area() float64 {
	return 3.14 * c.Radius * c.Radius
}

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

// Een andere structuur die de interface implementeert
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 dit voorbeeld fungeert Shape als contract (vergelijkbaar met een abstracte klasse of interface in andere talen), en Circle en Rectangle zijn concrete implementaties (analogen van gewone klassen). We kunnen instanties maken van Circle en Rectangle, maar niet direct van Shape. Beide structuren moeten ook de methoden Area() en Perimeter() implementeren om de interface Shape "te voldoen".