Hoe worden de concepten van objectgeoriënteerd…

In Go zijn de klassieke concepten van klassen, erfelijkheid en virtuele methoden die in andere talen (Java, C++) gebruikelijk zijn, niet aanwezig. Objectgeoriënteerd programmeren wordt gerealiseerd via:

Structs: Groeperen gegevens (velden).

type Person struct {
	Name string
	Age  int
}

Methoden: Functies met een gekoppelde ontvanger (struct of ander type). Hiermee kunnen structs gedrag krijgen.
```
func (p Person) Greet() string {
	return "Hello, my name is " + p.Name
}
```
- Ontvanger op waarde: De methode werkt met een kopie van de struct. Veranderingen binnen de methode beïnvloeden de originele struct niet.
- Ontvanger op pointer: De methode werkt met de originele struct via een pointer. Veranderingen binnen de methode beïnvloeden de originele struct.
Interfaces: Definiëren een set van methodesignatures waaraan een type moet voldoen. Ze bieden polymorfisme "door eend-typen" (duck typing). Een type implementeert impliciet een interface als het alle methoden implementeert.
```
type Greeter interface {
	Greet() string
}

func SayHello(g Greeter) string {
	return g.Greet()
}
```

Embedding: Hiermee kan een struct een andere struct of interface "embedden". Dit is geen erfelijkheid in de klassieke zin, maar meer compositie. De embedded struct wordt een anoniem veld, en de velden en methoden kunnen direct worden benaderd via de instantie van de struct die het embed.

type Employee struct {
	Person // embedded struct
	ID string
}

// Employee heeft nu de velden Name en Age, en ook de methode Greet()

e := Employee{
	Person: Person{Name: "Alice", Age: 30},
	ID:     "E123",
}
fmt.Println(e.Greet()) // aanroep van de Greet() methode van Person via Employee

OOP-concept	Implementatie in Go	Opmerkingen
Klassen	Structs	Er is geen expliciet sleutelwoord `class`
Encapsulatie	Exporteerbare (met hoofdletter) / niet-exporteerbare (met kleine letter) velden/methoden	Toegangscontrole op pakketniveau
Erfelijkheid	Embedding	Compositie in plaats van hiërarchische erfelijkheid
Polymorfisme	Interfaces	Duck typing, impliciete implementatie van interfaces

Hoe worden de concepten van objectgeoriënteerd programmeren (OOP) geïmplementeerd in de programmeertaal Go?