Como são implementados os conceitos de programação…

No Go, não existem conceitos clássicos de classes, herança e métodos virtuais que são comuns em outras linguagens (Java, C++). A programação orientada a objetos é implementada através de:

Estruturas (Structs): Agrupam dados (campos).

type Person struct {
	Name string
	Age  int
}

Métodos: Funções com um receptor associado (estrutura ou outro tipo). Permitem que as estruturas tenham comportamento.
```
func (p Person) Greet() string {
	return "Hello, my name is " + p.Name
}
```
- Receptor por valor: O método trabalha com uma cópia da estrutura. As alterações dentro do método não afetam a estrutura original.
- Receptor por ponteiro: O método trabalha com a estrutura original através de um ponteiro. As alterações dentro do método afetam a estrutura original.
Interfaces: Definem um conjunto de assinaturas de métodos que um tipo deve implementar. Proporcionam polimorfismo "por tipagem de pato" (duck typing). Um tipo implementa implicitamente uma interface se implementar todos os seus métodos.
```
type Greeter interface {
	Greet() string
}

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

Incorporação (Embedding): Permite que uma estrutura "incorpore" outra estrutura ou interface. Isto não é herança no sentido clássico, mas sim composição. A estrutura incorporada torna-se um campo anônimo, e seus campos e métodos podem ser acessados diretamente através da instância da estrutura que a incorpora.

type Employee struct {
	Person // estrutura incorporada
	ID string
}

// Employee agora possui os campos Name e Age, além do método Greet()

e := Employee{
	Person: Person{Name: "Alice", Age: 30},
	ID:     "E123",
}
fmt.Println(e.Greet()) // chamada ao método Greet() de Person através de Employee

Conceito de POO	Implementação em Go	Observações
Classes	Estruturas	Não há uma palavra-chave explícita `class`
Encapsulamento	Campos/métodos exportáveis (com letra maiúscula) / não exportáveis (com letra minúscula)	Controle de visibilidade ao nível do pacote
Herança	Incorporação (Embedding)	Composição em vez de herança hierárquica
Polimorfismo	Interfaces	Tipagem de pato, implementação implícita de interfaces

Como são implementados os conceitos de programação orientada a objetos (POO) na linguagem Go?