Explorando o polimorfismo na linguagem Go

Na programação orientada a objetos, o polimorfismo permite que os objetos exibam comportamentos diferentes com base em sua classe. Mas em Go, o conceito de polimorfismo não é implementado no sentido tradicional. Vamos nos aprofundar nas razões por trás disso e explorar como obter funcionalidade semelhante em Go.

Por que Go não possui polimorfismo tradicional

Go não é uma linguagem tradicional orientada a objetos. Adota uma abordagem diferente ao usar:

• Composição: Objetos compostos por outros objetos ou interfaces.
• Interfaces: Contratos que definem métodos e comportamentos para um tipo específico.

Ao contrário das linguagens orientadas a objetos, Go não oferece suporte à substituição de métodos ou métodos virtuais. Isso permite que Go mantenha um nível mais alto de segurança de tipo.

Implementando polimorfismo usando composição e interfaces

Para obter um comportamento semelhante ao polimorfismo em Go, podemos empregar as seguintes técnicas:

1. Criar uma interface comum: defina uma interface que represente os comportamentos ou métodos comuns que você deseja que seus tipos derivados representem implementar.
2. Implementar a interface: Implemente os métodos da interface em seus tipos derivados, cada um fornecendo sua própria implementação exclusiva.
3. Usar composição: Compor seus tipos derivados usando a interface comum como um campo. Isso permite que você trate todos os tipos derivados como instâncias da interface comum.

Exemplo:

package main

import "fmt"

// Common interface
type Foo interface {
    printFoo()
}

// Derived type with unique implementation
type FooImpl struct{}

func (f FooImpl) printFoo() {
    fmt.Println("Print Foo Impl")
}

// Derived type composed using the common interface
type Bar struct {
    FooImpl
}

// Function returning the common interface
func getFoo() Foo {
    return Bar{}
}

func main() {
    fmt.Println("Hello, playground")
    b := getFoo()
    b.printFoo()
}

Neste exemplo, Foo é a interface comum, FooImpl é o tipo derivado com sua própria implementação e Bar é um tipo derivado composto usando FooImpl. A função getFoo() retorna uma instância da interface Foo, permitindo-nos tratar diferentes tipos derivados como um tipo de interface.

Esta abordagem fornece uma forma de polimorfismo em Go, permitindo-nos tratar diferentes tipos derivados como instâncias de uma interface comum.