¿Qué es una interfaz?

En Go para decir que una clase implementa a una interfaz no es necesario hacerlo de manera explicita como otro lenguajes como c#, Java, etc. En go, se hace de manera implícita. es decir, solo necesita cumplir com las firmas que están en la interfaz.

package main

import "fmt"

func main(){

	figuras := make([]Area, 0)
	figuras = append(figuras, &Cuadrado{lado:4})
	figuras = append(figuras, &Rectangulo{lado:4, base: 6})
	figuras = append(figuras, &Triangulo{base:4, altura:10})

        // Calcular areas
	for _, f := range figuras {
		fmt.Println(f.CalcularArea())
	}

}

type Area interface {
	CalcularArea() int
}

// Cuadrado implementa Area de manera implicita
type Cuadrado struct {
	lado int
}

func (c *Cuadrado) CalcularArea() int {
	return c.lado * c.lado
}

// Rectangulo implementa Area de manera implicita
type Rectangulo struct {
	lado, base int
}

func (r *Rectangulo) CalcularArea() int {
	return r.lado * r.base
}

// Triangulo implementa Area de manera implicita
type Triangulo struct {
	base, altura int
}

func (t *Triangulo) CalcularArea() int {
	return (t.base * t.altura)/2
}

Como verán no se le coloca en ningún lugar que la clase X implementa la interfaz Y de manera explicita.

¡Esto sí que me ha sido de ayuda!

Las interfaces en Go simulan el comportamiento de conceptos como clases e interfaces de otros lenguajes, permitiendo también polimorfismo.

La condición para que un struct pueda considerarse de un tipo de interfaz específico se basa en su comportamiento. Esto quiere decir que a diferencia de otros lenguajes no se le definen explícitamente sus métodos, sino que es a partir de los métodos que tenga implementados, se va a inferir su tipo de interfaz.

Siempre me cuesta trabajo entender interfaces

El objetivo de las interfaces en Go es crear código versátil, flexible y modular. El enfoque de Go usa para la reutilización de código es la composición. y esto se hace con las interfaces.

• https://www.digitalocean.com/community/tutorials/how-to-use-interfaces-in-go-es

Intente hace el código del que se habla en esta lección, espero les sirva.

package main

import (
	"fmt"
	"math"
)

type geometry interface {
	calculateArea() float64
	calculatePerimeter() float64
}

func printArea(g geometry) {
	fmt.Println(g.calculateArea())
}
func printPerimeter(g geometry) {
	fmt.Println(g.calculatePerimeter())
}

type circle struct {
	radio float64
}

// Cuadrado al tener ambos metodos de la interfaz Geometrico lo implementa de manera implicita
func (circle *circle) calculateArea() float64 {
	return 3.14159 * math.Pow(circle.radio, 2)
}
func (circle *circle) calculatePerimeter() float64 {
	return 3.14159 * (circle.radio * 2)
}

type square struct {
	side float64
}

// Circulo al tener ambos metodos de la interfaz Geometrico lo implementa de manera implicita
func (square *square) calculateArea() float64 {
	return math.Pow(square.side, 2)
}
func (square *square) calculatePerimeter() float64 {
	return square.side * 4
}

func main() {
	var square = &square{side: 3}
	fmt.Println("----- Cuadrado implementando Geometrico -----")
	fmt.Println(geometry.calculateArea(square))
	fmt.Println(geometry.calculatePerimeter(square))

	var circle = &circle{radio: 3}
	fmt.Println("----- Circulo implementando Geometrico -----")
	fmt.Println(geometry.calculateArea(circle))
	fmt.Println(geometry.calculatePerimeter(circle))
}

muy interesante esta explicación.

Go es el mejor lenguaje de programación para Backend.

Ejemplo: tenemos la interfaz medioDeTransporte con un metodo llamado desplazar() y una struct llamada automovil.
Para que la struc automovil se pueda considerar un medioDeTransporte deberia implementar su metodo desplazar().
Algo asi lo entiendo.

Que buena explicacion!

efectivamente en Java las interfaces se declaran explicitamente con el operador implements… con GO se declaran implícitamente los comportamientos de la misma 😃

ok,

Esto me recuerdo a los templates de C/C++ (tipo de dato genérico)
Las interfaces en C/C++ significaban algo diferente a lo que es en GO.

para los que ya saben programacion orientada a objetos o POO esto sera mas facil de entender