Como funciona o modelo orientado a objetos em Go…

No Go, não existe um modelo orientado a objetos tradicional com uma hierarquia profunda de herança de classes. Em vez disso, usam-se:

Estruturas (Structs): Definem campos de dados, semelhantes às classes sem métodos.
```
type Person struct {
    Name string
    Age  int
}
```
Métodos: Funções associadas a uma estrutura específica. São definidos separadamente da estrutura.
```
func (p Person) Greet() string {
    return "Olá, meu nome é " + p.Name
}

func (p *Person) CelebrateBirthday() {
    p.Age++
}
```
- Métodos com receptor por valor (por exemplo, (p Person)) trabalham com uma cópia da estrutura.
- Métodos com receptor por ponteiro (por exemplo, (p *Person)) trabalham com a estrutura original, permitindo modificar seus campos.
Interfaces: Conjuntos de assinaturas de métodos. Os tipos que implementam todos os métodos de uma interface satisfazem implicitamente essa interface. Essa é a base do polimorfismo em Go.
```
type Greeter interface {
    Greet() string
}

// Person implementa implicitamente Greeter
```

Composição (Incrustação): Em vez de herança, uma estrutura pode incrustar outra estrutura, acessando seus campos e métodos.

type Employee struct {
    Person // Incrusta a estrutura Person
    ID     string
}

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

Os campos e métodos incrustados estão disponíveis diretamente:

e := Employee{
    Person: Person{Name: "Alice", Age: 30},
    ID:     "E123",
}
fmt.Println(e.Name)     // Acesso ao campo Name através da Person incrustada
fmt.Println(e.Greet())  // Chamada do método Greet através da Person incrustada
fmt.Println(e.GetID())  // Chamada do método Employee

Assim, o modelo orientado a objetos em Go baseia-se na composição de estruturas e comportamentos definidos por interfaces, e não numa hierarquia clássica de herança de classes.

Como funciona o modelo orientado a objetos em Go?