Interfaces y Listas de Interfaces en Go: Conceptos y Aplicaciones
Contenido del curso
Education Mobility Solutions SAS
Profesor
David Gonzalez
JUAN PABLO MAYORGA MENDIETA
IVAN DARIO CHIPATECUA CABEZAS
Said Hernandez
Williams Bricaire Vallejo Mariscal
Andres Vanegas
David Leonardo Baron Avilan
Wilson Fernando Antury Torres
Steven Javier Arevalo Poveda
Julio Cesar Estrada Marcial
Gabriel Thomas
Osmandi Gomez
Adrián Olmedo
Fernando Eladio Alvarez Noya
Nicolas Estefan Lopez
Eliaz Bobadilla
Jhon Eduard Bocanegra Ortiz
Miguel Angel Luque Acevedo
Chris Amachi
Oscar Callisaya
Rodolfo Valencia Rodriguez
Josue Martin Chi Perera
Fernando Eladio Alvarez Noya
Luna Mariana Cagua Clavijo
AGEO ANDRÉS FUENTES MERIÑO
Vale aclara algo:
las funciones en Go se definen de la siguiente manera:
func nameFunc() { // body de la función }
El nombre de las funciones no se pueden repetir en un mismos paquete, pero que esta pasando con las func area que se definieron dos veces en esta clase?
Lo que esta sucediendo es que no son simplemente funciones, en Go se les conoce como Methods. Un método es una función con un argumento de receptor especial. que debe de ser de tipo struct o interface y se definen de la siguiente manera:
func (receiver type) nameFunc() { // body del metodo }
Una buena practica es nombrar a nuestro receptor con la primera letra del struct o interface a la que estamos haciendo referencia, por ejemplo:
type cuadrado struct { lado float32 } func (c cuadrado) area() float32 { return c.lado * c.lado }
¡Increíble aporte!
Excelente aporte, muchas gracias!!
Reto
package main import ( "fmt" "math" "reflect" ) type figure2D interface { getArea() float64 } type square struct { base float64 } type rectangle struct { high float64 width float64 } type trapezoid struct { baseA float64 baseB float64 high float64 } type circle struct { radio float64 } func (s square) getArea() float64 { return s.base * s.base } func (r rectangle) getArea() float64 { return r.high * r.width } func (t trapezoid) getArea() float64 { return ((t.baseA + t.baseB) / 2) * t.high } func (c circle) getArea() float64 { return math.Pi * math.Pow(c.radio, 2) } func calculateArea(f figure2D) { fmt.Printf("Area of %s: %.2f\n", reflect.TypeOf(f).Name(), f.getArea()) } func main() { mySquare := square{base: 5} myRectangle := rectangle{width: 4, high: 5} myTrapezoid := trapezoid{baseA: 18, baseB: 10, high: 5} myCircle := circle{radio: 4} calculateArea(mySquare) calculateArea(myRectangle) calculateArea(myTrapezoid) calculateArea(myCircle) }
Buen Codigo
Solo como comentario, la altura en Ingles es Height no High. Saludos!
Una aclaracion sobre el doble corchete
myInterface := []{}{"hola", 12, true}
Si se les dificulto un poco el funcionamiento de las interfaces en Golang (ya que en Java o Python son más como contratos, en donde cumplimos el implementar una función en una clase), espero que mi explicación les ayude
Tomo a las interfaces más como herramientas para hacer parámetros de Structs en funciones universales, me explico:
Creamos esta función para calcular el area de cuadrado
func (c cuadrado) area() float64{ return c.base * c.base }
Normalmente tendríamos que invocar el método del struct cada que queramos usar la función
myCuadrado := cuadrado{base:2} myCuadrado.area()
Pero gracias a las interfaces, ahora podemos pasar el Struct myCuadrado como parametro y reutilizar una misma funcion en multiples Structs
//Creamos un Struct triangulo type triangulo struct{ base float64 altura float64 } //Instanciamos el struct triangulo myTriangulo := triangulo{base: 2, altura: 4} //Creamos la interface type figuraGeometrica2d interface{ area() float64 } //Ahora tenemos una función que toma como parametro Structs func calcularArea(f figuraGeometrica2d){ fmt.Println("El area de tu figura es de: ", f.area) }
Y ahora, gracias a la interface, podemos pasar a todo Struct que tenga un método area() como parametro de la funcion calcularArea
calcularArea(myCuadrado) calcularArea(myTriangulo)
Si se les dificultó entender el concepto o uso de interface, espero haberles ayudado (:
Quizá es bueno tener en cuenta que aquí no se implementan interfaces explicitamente sino implicitamente, es por eso que solo con que el método se llame área se hace la asociación!
Algo que no se menciona en el curso y puede generar duda es como la función calculate sabe que los structs que pasamos están implementando la interfaz que estamos esperando. Esto pasa porque GO de forma implícita implementa la interfaz cuando un struct tiene todos los métodos que esa interfaz necesita.
Adicional recuerden que en ese ejemplo se aplican algunos principios SOLID como: Interface segregation principle, Liskov substitution y Dependency inversion principle.
Hola a todos/todas. tengo una duda. Como go sabe que la estructura implementa la interfaz. En java, normalmente lo que uno hace es decirle a cada clase que interfaz implementa con el keyword implements . En este ejemplo, no veo que a la estructura se le diga explícitamente que va a implementar la interfaz. De antemano muchas gracias
Eso es porque Go lo hace de forma implícita, ya que utiliza Duck typing (Si camina como pato y hace quack como un pato, entonces es un pato)
En Go no existe la palabra clave implements ni parecido, una estructura implementa una interfaz de forma implícita, cuando tiene métodos con el mismo nombre y firma que los que tiene la interfaz.
Si quieres saber visualmente cuáles estructuras en tu código implementan tal cual interfaz puedes usar la herramienta goplantuml https://github.com/jfeliu007/goplantuml
Salio con fritas...
Este es el principal
package main import ( cua "curso_golang_basico/src/12Interfaces/pkgcuadrado" inter "curso_golang_basico/src/12Interfaces/pkginterfaces" rec "curso_golang_basico/src/12Interfaces/pkgrectangulo" "fmt" ) func main() { var micuadrado cua.Cuadrado micuadrado.CreaLado(4) var mirec rec.Rectangulo mirec.CreaRec(8, 3) fmt.Println(micuadrado) fmt.Println(mirec) // Sin interfaces fmt.Println("\nSin interfaces: ") fmt.Println("Area cuadrado: ", micuadrado.Area()) fmt.Println("Area rectangulo: ", mirec.Area()) // Con interfaces fmt.Println("\nCon interfaces") inter.Calcular(micuadrado) inter.Calcular(mirec) }
Este es el package cuadrado (un subdir dentro del principal)
package pkgcuadrado import "fmt" type Cuadrado struct { lado int } func (c *Cuadrado) CreaLado(l int) { c.lado = l } func (c Cuadrado) String() string { return fmt.Sprintf("Cuadrado de lado = %d", c.lado) } func (c Cuadrado) Area() int { return c.lado * c.lado }
Este es ahora el package rectangulo
package pkgrectangulo import "fmt" type Rectangulo struct { largo int ancho int } func (r *Rectangulo) CreaRec(l, a int) { r.largo = l r.ancho = a } func (r Rectangulo) String() string { return fmt.Sprintf("Rectangulo de largo = %d y ancho = %d", r.largo, r.ancho) } func (r Rectangulo) Area() int { return r.ancho * r.largo }
Y finalmente poniendome creativo un package para las interfaces...
package pkginterfaces import "fmt" type figuras2D interface { Area() int } func Calcular(f figuras2D) { fmt.Println("Area: ", f.Area()) }
Y lo mejor de todo es que anda! :)
Holas Osmandi, seria chevere que pudieras agregar a este video la importancia de las interfaces, teniendo en cuenta que hay personas que vienen sin saber POO.
Saludos.
Me gusta mucho la forma de declarar las listas de interfaces:
package main import "fmt" func main() { myInterface := []interface{}{"Hola", 121, 4.90} fmt.Println(myInterface...) }
Mas documentado aquí.
Reto 🥳
//Main package main import ( pk "curso_golang_platzi/src/mypackage" f "fmt" ) func main() { myCuadrado := pk.Cuadrado{Base: 4} f.Println(myCuadrado) pk.Calcular(myCuadrado) myRectangulo := pk.Rectangulo{Base: 2, Altura: 4} f.Println(myRectangulo) pk.Calcular(myRectangulo) myCirculo := pk.Circulo{Radio: 5} f.Println(myCirculo) pk.Calcular(myCirculo) } //mypackage package mypackage import "fmt" type Figuras2D interface { area() float64 } type Cuadrado struct { Base float64 } type Rectangulo struct { Base float64 Altura float64 } type Circulo struct { Radio float64 } func (c Cuadrado) area() float64 { return c.Base * c.Base } func (r Rectangulo) area() float64 { return r.Base * r.Altura } func (ci Circulo) area() float64 { return (ci.Radio * ci.Radio) * 3.1415 } func Calcular(f Figuras2D) { fmt.Println("Área:", f.area()) }
Reto: main.go
package main import ( fg "curso-golang/src/18.Interfaces/figuras" "fmt" ) type figuras2D interface { Area() float64 } func calcular(f figuras2D) { fmt.Printf("Area: %v\n", f.Area()) } func main() { miCuadrado := fg.NewCuadrado(2) miRectangulo := fg.NewRectangulo(2, 4) miCirculo := fg.NewCirculo(3.2) miTriangulo := fg.NewTriangulo(7.8, 2.9) calcular(miCuadrado) calcular(miRectangulo) calcular(miCirculo) calcular(miTriangulo) }
cuadrado.go
package figuras type cuadrado struct { base float64 } func NewCuadrado(bs float64) cuadrado { return cuadrado{base: bs} } func (c cuadrado) Area() float64 { return c.base * c.base }
rectangulo.go
package figuras type rectangulo struct { base float64 altura float64 } func NewRectangulo(bs, alt float64) rectangulo { return rectangulo{base: bs, altura: alt} } func (r rectangulo) Area() float64 { return r.altura * r.base }
circulo.go
package figuras import "math" type circulo struct { radio float64 } func NewCirculo(rd float64) circulo { return circulo{radio: rd} } func (c circulo) Area() float64 { return math.Pi * c.radio * c.radio }
triangulo.go
package figuras type triangulo struct { base float64 altura float64 } func NewTriangulo(bs, alt float64) triangulo { return triangulo{base: bs, altura: alt} } func (t triangulo) Area() float64 { return t.base * t.altura / 2 }
Código para usar un poder especial de diferentes formas con diferentes pokemon. El resultado: la cantidad de poder que aumenta el pokemon.
package main import "fmt" type pokemonPwrs interface { usePwr() int } type myElecPokemon struct { name string volts int level int } type myFirePokemon struct { name string flames int level int } func (fPoke myFirePokemon) usePwr() int { return fPoke.flames * fPoke.level } func (ePoke myElecPokemon) usePwr() int { return ePoke.volts * ePoke.level } func useSpecialPwrs(p pokemonPwrs) { fmt.Printf("Power: %v \n", p.usePwr()) } func main() { var pikachu = myElecPokemon{name: "Pikachu", volts: 10, level: 3} var litten = myFirePokemon{name: "Litten", flames: 25, level:5} useSpecialPwrs(pikachu) useSpecialPwrs(litten) }
Me tomo un tiempo entender q es la lista de interfaces, este stackoverflow explica bien por q la repeticion de {}{} https://stackoverflow.com/questions/57149795/what-does-the-double-curly-brace-mean-in-interface/57150132
Este feature de Go, te permite crear un slice indicando q INTERFACE pertenecen todos los items creados:
// Slice de objetos de la interfaz figuras2D figuras := []figuras2D{cuadrado{base: 2}, rectangulo{base: 2, altura: 4}} for _, figura := range figuras { fmt.Println(figura) calcular(figura) }
Y al intentar colocar un objeto q no tiene la implementacion de esa interfaz, pues el editor y al correr te indicaran q no implementa lo q indica la interfaz. Ese feature realmente me gusto
// Agregando un STRING en el slice figuras := []figuras2D{cuadrado{base: 2}, rectangulo{base: 2, altura: 4}, "invalid object"} // Al ejecutarlo PS C:\git\test-go> go run .\src\interfacesListas.go # command-line-arguments src\interfacesListas.go:55:76: cannot use "invalid object" (constant of type string) as type figuras2D in array or slice literal: string does not implement figuras2D (missing area method)
yo diria que esta clase explica un poco de polimorfismo con las estructuras e interfaces
Reto completo
Archivo main
package main import ( mpk "curso_golang_basico/src/mypackage" "fmt" ) func main() { //Entrada de valores myCuadrado := mpk.Cuadrado{Base: 2} myRectangulo := mpk.Rectangulo{Base: 3, Altura: 5} //Impresión de valores fmt.Println(myCuadrado) fmt.Println(myRectangulo) //Calculo de valores mpk.Calcular(myCuadrado) mpk.Calcular(myRectangulo) //SALIDA // Un lado del cuadrado mide: 2 cm // La base del rectangulo mide: 3 cm y la altura del rectangulo mide: 5 cm // El área es: 4 cm2 // El área es: 15 cm2 }
Archivo mypackage
package mypackage import "fmt" //PARTE 4. type figura2D interface { Area() float64 } //PARTE 1. type Cuadrado struct { Base float64 } //PARTE 1. type Rectangulo struct { Base float64 Altura float64 } //Parte 3. func (c Cuadrado) Area() float64 { return c.Base * c.Base } //PARTE 3. func (r Rectangulo) Area() float64 { return r.Base * r.Altura } //PARTE 5. func Calcular(f figura2D) { fmt.Println("El área es:", f.Area(), "cm2") } //Para la impresión del valor entrante de uncuadrado func (C Cuadrado) String() string { return fmt.Sprintf("Un lado del cuadrado mide: %v cm", C.Base) } //Para la impresión de los valores entrantes de un rectangulo func (C Rectangulo) String() string { return fmt.Sprintf("La base del rectangulo mide: %v cm y la altura del rectangulo mide: %v cm", C.Base, C.Altura) }
Recordando Java y ocultando los atributos del struct me puse a jugar con lo siguiente:
package main import ( cua "curso_golang_basico/src/12Interfaces/pkgcuadrado" "fmt" ) func main() { var micuadrado cua.Cuadrado micuadrado.CreaLado(4) fmt.Println("Imprimo micuadrado: ", micuadrado) }
Y en el package...
package pkgcuadrado import "fmt" type Cuadrado struct { lado int } func (c *Cuadrado) CreaLado(l int) { c.lado = l } func (c Cuadrado) String() string { return fmt.Sprintf("Cuadrado de lado = %d", c.lado) }
De esta manera no hago publico informacion que no estaria bueno exponer :)
tengo mis dudas sobre las importaciones, no me es algo tan facil, pero asi quedo :)
Reto cumplido
