¿Cómo se implementa la herencia en Golang?

En Go no existe la herencia de clases tradicional, como en Java o C++. En su lugar, se utilizan dos mecanismos:

1. Incrustación (Embedding):

   • La incrustación permite incorporar una estructura o tipo en otra.
   • El tipo incrustado "transmite" sus campos y métodos al tipo que lo incrusta.
   • El acceso a los campos y métodos del tipo incrustado se realiza directamente, como si estuvieran definidos en el tipo que lo incrusta.
   • Esto imita la composición, pero con una sintaxis de acceso más conveniente, similar a la herencia.

   package main
   
   import "fmt"
   
   type Engine struct {
       Type string
   }
   
   func (e Engine) Start() {
       fmt.Println(e.Type, "motor encendido")
   }
   
   type Car struct {
       Engine // Incrustación de la estructura Engine
       Model  string
   }
   
   func main() {
       car := Car{
           Engine: Engine{Type: "V8"},
           Model:  "Mustang",
       }
   
       // Acceso directo a los campos y métodos de la estructura incrustada
       fmt.Println("Modelo del coche:", car.Model)
       car.Start() // Llamada al método de la estructura incrustada
   }
   

2. Interfaces:

   • Las interfaces definen un conjunto de métodos que un tipo debe implementar.
   • Definen "comportamiento", no estructura de datos.
   • El tipo no necesita declarar explícitamente que implementa la interfaz; basta con implementar todos los métodos definidos en ella.
   • Las interfaces proporcionan polimorfismo.

   package main
   
   import "fmt"
   
   type Speaker interface {
       Speak()
   }
   
   type Dog struct {
       Name string
   }
   
   func (d Dog) Speak() {
       fmt.Println(d.Name, "dice Woof!")
   }
   
   type Cat struct {
       Name string
   }
   
   func (c Cat) Speak() {
       fmt.Println(c.Name, "dice Miau!")
   }
   
   func main() {
       animals := []Speaker{
           Dog{Name: "Buddy"},
           Cat{Name: "Whiskers"},
       }
   
       for _, animal := range animals {
           animal.Speak() // Llamada polimórfica al método Speak
       }
   }
   

La combinación de incrustación e interfaces permite a Go lograr flexibilidad y reutilización de código sin las complicaciones y problemas asociados con la herencia tradicional (por ejemplo, el problema del "diamante"). En Go, se prefiere la composición y las interfaces sobre jerarquías de herencia.