Jak je v Go uspořádán objektově orientovaný model…

V jazyce Go neexistuje tradiční objektově orientovaný model s hlubokou hierarchií dědičnosti tříd. Místo toho se používají:

Struktury (Structs): Definují datová pole, podobně jako třídy bez metod.
```
type Person struct {
    Name string
    Age  int
}
```
Metody: Funkce vázané na konkrétní strukturu. Jsou definovány odděleně od struktury.
```
func (p Person) Greet() string {
    return "Ahoj, jmenuji se " + p.Name
}

func (p *Person) CelebrateBirthday() {
    p.Age++
}
```
- Metody s přijímačem hodnoty (například (p Person)) pracují s kopií struktury.
- Metody s přijímačem ukazatele (například (p *Person)) pracují s originálem struktury, což umožňuje měnit její pole.
Rozhraní (Interfaces): Sady podpisů metod. Typy, které implementují všechny metody rozhraní, implicitně splňují toto rozhraní. To je základ polymorfismu v jazyce Go.
```
type Greeter interface {
    Greet() string
}

// Person implicitně implementuje Greeter
```

Kompocice (Vkládání): Místo dědičnosti může jedna struktura vkládat jinou strukturu, čímž získává přístup k jejím polím a metodám.

type Employee struct {
    Person // Vkládáme strukturu Person
    ID     string
}

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

Vložená pole a metody jsou dostupné přímo:

e := Employee{
    Person: Person{Name: "Alice", Age: 30},
    ID:     "E123",
}
fmt.Println(e.Name)     // Přístup k poli Name přes vloženou Person
fmt.Println(e.Greet())  // Volání metody Greet přes vloženou Person
fmt.Println(e.GetID())  // Volání metody Employee

Tímto způsobem je objektově orientovaný model v jazyce Go založen na kompozici struktur a chování definovaném rozhraními, nikoliv na klasické hierarchii dědičnosti tříd.

Jak je v Go uspořádán objektově orientovaný model?