Hoe is het objectgeoriënteerde model in Go opgebouwd…

In Go bestaat geen traditioneel objectgeoriënteerd model met een diepe hiërarchie van klasse-erfenis. In plaats daarvan worden gebruikt:

Structs: Definiëren gegevensvelden, vergelijkbaar met klassen zonder methoden.
```
type Person struct {
    Name string
    Age  int
}
```
Methoden: Functies gekoppeld aan een specifieke structuur. Ze worden apart van de structuur gedefinieerd.
```
func (p Person) Greet() string {
    return "Hallo, mijn naam is " + p.Name
}

func (p *Person) CelebrateBirthday() {
    p.Age++
}
```
- Methoden met receiver-waarde (bijvoorbeeld (p Person)) werken met een kopie van de structuur.
- Methoden met receiver-wijzer (bijvoorbeeld (p *Person)) werken met het origineel van de structuur, waardoor het mogelijk is om velden te wijzigen.
Interfaces: Verzamelingen van methodesignaturen. Types die alle methoden van een interface implementeren, voldoen impliciet aan die interface. Dit is de basis van polymorfisme in Go.
```
type Greeter interface {
    Greet() string
}

// Person implementeert impliciet Greeter
```

Samenstelling (Incrustatie): In plaats van erfenis kan een structuur een andere structuur inbedden, waardoor toegang tot de velden en methoden wordt verkregen.

type Employee struct {
    Person // Incrusteert de Person-structuur
    ID     string
}

func (e Employee) GetID() string {
    return e.ID
}

Ingebedde velden en methoden zijn direct toegankelijk:

e := Employee{
    Person: Person{Name: "Alice", Age: 30},
    ID:     "E123",
}
fmt.Println(e.Name)     // Toegang tot veld Name via de ingebedde Person
fmt.Println(e.Greet())  // Aanroep van methode Greet via de ingebedde Person
fmt.Println(e.GetID())  // Aanroep van methode Employee

Op deze manier is het objectgeoriënteerde model in Go gebaseerd op de samenstelling van structuren en gedrag dat wordt gedefinieerd door interfaces, en niet op een klassieke hiërarchie van klasse-erfenis.

Hoe is het objectgeoriënteerde model in Go opgebouwd?