No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

¿Qué es una interfaz?

18/42
Recursos

Aportes 12

Preguntas 0

Ordenar por:

Los aportes, preguntas y respuestas son vitales para aprender en comunidad. Regístrate o inicia sesión para participar.

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.

Siempre me cuesta trabajo entender interfaces

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.

¡Esto sí que me ha sido de ayuda!

muy interesante esta explicación.

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.

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.

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))
}

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