Como é implementada a herança em Golang?

No Go, não há herança de classes tradicional, como em Java ou C++. Em vez disso, utilizam-se dois mecanismos:

1. Incorporação (Embedding):

   • A incorporação permite incorporar uma estrutura ou tipo numa outra.
   • O tipo incorporado "transmite" os seus campos e métodos ao tipo que o incorpora.
   • O acesso aos campos e métodos do tipo incorporado é feito diretamente, como se fossem definidos no tipo que o incorpora.
   • Isto imita a composição, mas com uma sintaxe de acesso mais conveniente, semelhante à herança.

   package main
   
   import "fmt"
   
   type Engine struct {
       Type string
   }
   
   func (e Engine) Start() {
       fmt.Println(e.Type, "motor ligado")
   }
   
   type Car struct {
       Engine // Incorporação da estrutura Engine
       Model  string
   }
   
   func main() {
       car := Car{
           Engine: Engine{Type: "V8"},
           Model:  "Mustang",
       }
   
       // Acesso direto aos campos e métodos da estrutura incorporada
       fmt.Println("Modelo do carro:", car.Model)
       car.Start() // Chamada do método da estrutura incorporada
   }
   

2. Interfaces:

   • As interfaces definem um conjunto de métodos que um tipo deve implementar.
   • Elas definem "comportamento", não estrutura de dados.
   • O tipo não precisa declarar explicitamente que implementa a interface; basta implementar todos os métodos definidos.
   • As interfaces proporcionam polimorfismo.

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

A combinação de incorporação e interfaces permite que o Go alcance flexibilidade e reutilização de código sem as complexidades e problemas associados à herança tradicional (por exemplo, o problema do "diamante"). Em Go, prefere-se composição e interfaces em vez de hierarquias de herança.