¿Cómo se implementan los conceptos de programación…

En Go no existen las conceptos clásicos de clases, herencia y métodos virtuales que son comunes en otros lenguajes (Java, C++). La programación orientada a objetos se implementa a través de:

Estructuras (Structs): Agrupan datos (campos).

type Person struct {
	Name string
	Age  int
}

Métodos: Funciones con un receptor asociado (estructura u otro tipo). Permiten que las estructuras tengan comportamiento.
```
func (p Person) Greet() string {
	return "Hello, my name is " + p.Name
}
```
- Receptor por valor: El método trabaja con una copia de la estructura. Los cambios dentro del método no afectan a la estructura original.
- Receptor por puntero: El método trabaja con la estructura original a través de un puntero. Los cambios dentro del método afectan a la estructura original.
Interfaces: Definen un conjunto de firmas de métodos que un tipo debe implementar. Proporcionan polimorfismo "por tipificación de pato" (duck typing). Un tipo implementa implícitamente una interfaz si implementa todos sus métodos.
```
type Greeter interface {
	Greet() string
}

func SayHello(g Greeter) string {
	return g.Greet()
}
```
Incrustación (Embedding): Permite que una estructura "incruste" otra estructura o interfaz. Esto no es herencia en el sentido clásico, sino más bien composición. La estructura incrustada se vuelve un campo anónimo, y sus campos y métodos se pueden acceder directamente a través de la instancia de la estructura que la incrusta.
```
type Employee struct {
	Person // estructura incrustada
	ID string
}

// Employee ahora tiene los campos Name y Age, además del método Greet()

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

Concepto de POO	Implementación en Go	Comentarios
Clases	Estructuras	No hay una palabra clave explícita `class`
Encapsulación	Campos/métodos exportables (con letra mayúscula) / no exportables (con letra minúscula)	Control de visibilidad a nivel de paquete
Herencia	Incrustación (Embedding)	Composición en lugar de herencia jerárquica
Polimorfismo	Interfaces	Tipificación de pato, implementación implícita de interfaces

¿Cómo se implementan los conceptos de programación orientada a objetos (POO) en el lenguaje Go?