¿Cómo está estructurada el modelo orientado a objetos…

En Go no existe un modelo orientado a objetos tradicional con una jerarquía profunda de herencia de clases. En su lugar, se utilizan:

Estructuras (Structs): Definen campos de datos, similares a las clases sin métodos.
```
type Person struct {
    Name string
    Age  int
}
```
Métodos: Funciones vinculadas a una estructura específica. Se definen por separado de la estructura.
```
func (p Person) Greet() string {
    return "Hola, mi nombre es " + p.Name
}

func (p *Person) CelebrateBirthday() {
    p.Age++
}
```
- Los métodos con receptor por valor (por ejemplo, (p Person)) trabajan con una copia de la estructura.
- Los métodos con receptor por puntero (por ejemplo, (p *Person)) trabajan con la estructura original, permitiendo modificar sus campos.
Interfaces: Conjuntos de firmas de métodos. Los tipos que implementan todos los métodos de una interfaz satisfacen implícitamente esa interfaz. Esto es la base del polimorfismo en Go.
```
type Greeter interface {
    Greet() string
}

// Person implementa implícitamente Greeter
```

Composición (Incrustación): En lugar de herencia, una estructura puede incrustar otra estructura, accediendo a sus campos y métodos.

type Employee struct {
    Person // Incrusta la estructura Person
    ID     string
}

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

Los campos y métodos incrustados están disponibles directamente:

e := Employee{
    Person: Person{Name: "Alice", Age: 30},
    ID:     "E123",
}
fmt.Println(e.Name)     // Acceso al campo Name a través de Person incrustada
fmt.Println(e.Greet())  // Llamada al método Greet a través de Person incrustada
fmt.Println(e.GetID())  // Llamada al método Employee

De esta forma, el modelo orientado a objetos en Go se basa en la composición de estructuras y comportamientos definidos por interfaces, y no en una jerarquía clásica de herencia de clases.

¿Cómo está estructurada el modelo orientado a objetos en Go?