Manipulação de interfaces em Go

As interfaces Go fornecem um mecanismo poderoso para abstração. No entanto, seu uso pode representar certos desafios ao lidar com múltiplas interfaces e tipos concretos.

Compreendendo as interfaces Go

Ao contrário de linguagens como C e Java, Go não oferece suporte direto herança de classe. Em vez disso, as interfaces servem como uma forma de polimorfismo que permite que tipos não relacionados implementem o mesmo conjunto de métodos. Eles não definem nenhum detalhe de implementação subjacente.

Múltiplas interfaces e implementação

No seu exemplo, você encontra um problema ao tentar acessar a representação de string ("String( )") para uma instância da interface "Cartão". Isso ocorre porque a interface em si não define esse método.

Práticas recomendadas para design de interface

Para resolver esse problema e otimizar o design de sua interface, considere o seguinte:

• Evitar ocultar a implementação: Embora inicialmente você possa querer ocultar seu tipo de estrutura para impor o encapsulamento, Go não é exportado ("minúsculas") Os campos struct já evitam a manipulação direta de dados internos.
• Retornar tipos concretos: Na maioria dos casos, é preferível retornar tipos concretos em vez de interfaces. Isso simplifica o código do cliente e mantém a clareza.

• Declarar interfaces prematuras (se necessário): Declare interfaces apenas antes da implementação se:

  • Múltiplas implementações de a interface existe e os clientes trocam dinamicamente entre eles.
  • Os clientes usam a interface com funções digitadas estaticamente ou tipos.
• Mitigar o impacto da documentação: A declaração prematura de interfaces pode afetar a clareza da documentação. Use os comentários da documentação para explicar a finalidade e as restrições de quaisquer métodos de interface.

Abordagem Alternativa

Em vez de usar uma interface para definir a API "Card" e conversão de string, considere usar embedding:

type Card struct {
    cardNum int
    face    string
    suit    string
}

// Interface for the Card's game-related behavior
type GameCard interface {
    GetFace() string
    GetSuit() string
}

// Embedded interface for string conversion
type Stringer interface {
    String() string
}

// Implement both interfaces on the Card type
func (c *Card) GetFace() string {
    return c.face
}

func (c *Card) GetSuit() string {
    return c.suit
}

func (c *Card) String() string {
    return fmt.Sprintf("%s%s ", c.GetFace(), c.GetSuit())
}

// Usage:
func main() {
    // Create a Card instance and access its methods
    card := Card{cardNum: 0}
    fmt.Println(card.GetFace())
    fmt.Println(card.GetSuit())
    fmt.Println(card.String())
}

Essa abordagem permite definir interfaces separadas para diferentes interesses (lógica do jogo e conversão de strings) e implementá-las na mesma estrutura.