Interfaces

Clase 21 de 34 • Curso de Programación en Go 2016

Luis Quintanilla

student•

No dudo que sepa mucho el lenguaje go, pero metologia de enseñanza les falta platzi, buenos programadores en sus cursoso pocos profesores que sepan enseñar con metodologia la programacion. Saludos.

Elvis Sánchez

student•

Muuuuuuuy cierto.

Cristian Orlando Rincon Bonilla

student•

Es bien confusa su forma de explicar

Equipo Mecubro

student•

El código desprolijo y los ejemplos super confusos, da la impresión que ni siquiera sabe lo que está explicando.

Dayana Morente

student•

Mario Menjívar

student•

Creo que provoca confusión la creación del método callSuscribe() para explicar que son realmente las interfaces.

Cómo se menciona en el video, se utilizan para una especie de “normalización” de tus estructuras.

Chequen mi código: https://imgur.com/a/VBxS7

Y pueden darle un vistazo a esto por si a más de alguno no le termino de cuadrar: https://gobyexample.com/interfaces

Iván Toro

student•

package structs

type Platzi interface {
  Subscribe(name string)
}

func Interfaces(){
  course := Course{name: "Go", class: 50, skills: []string{"Backend"}}
  carrer := new(Carrer)
  carrer.name = "Go carrer"
  carrer.class = 150
  name := "Ivan"
  callSubscribe(carrer, name)
  callSubscribe(course, name)
}

func callSubscribe(duck Platzi, name string){
  duck.Subscribe(name)
}

Qenta SAS

student•

package estructuras

// Platzi es una interfaz para subscribe
type Platzi interface {
	Subscribe(name string)
}

// InterfaceTest recibe los metodos "Estudio" y "Carrera" para hacer una estructura independiente de cada uno
func InterfaceTest() {
	ObjetoInterface := new(Estudio)
	ObjetoInterface.Name = "Interfaces"
	ObjetoInterface.Persona = "Zerofelx"
	ObjetoInterface.Skills = []string{"Probando", "Esta", "Wea"}

	objetoCurso3 := new(Carrera)
	objetoCurso3.Name = "Interfaces"
	objetoCurso3.Slug = "Interfaces"
	objetoCurso3.Url = "www.youtube.com"

	callSubscribe(ObjetoInterface)
	callSubscribe(objetoCurso3)
}

func callSubscribe(p Platzi) {
	p.Subscribe("Zerofelx")
}

Oscar Alejandro Becerra Cervantes

student•

De acuerdo, según lo que nos va explicando, Go no funciona como debería funcionar un lenguaje orientado a objetos (POO)

Un ejemplo claro es el Interfaz. A diferencia de otros lenguajes que si son POO, aquí no se usa el keyword "implement". Las estructuras nunca se va a juntar con las interfaces, lo que las une son las funciones. ¿Como funciona?

package main

import "fmt"

//Creamos dos estructuras
type Perro struct {
	Nombre string
}

type Gato struct {
	Nombre string
}

/*Ambos pueden saludar porque son Animales asi que las funciones estaran en la interface Animal */
type Animal interface{
	Saludar()
}







/*Como ya tenemos la funcion vacia lo que haremos es "llenarla" o 
escribir como funcionara para cada animal (el Gato y el Perro)*/

func (g Gato) Saludar(){
	fmt.Printf("Hola yo soy %s \n", g.Nombre)
}

func (p Perro) Saludar(){
	fmt.Printf("Hola yo soy %s \n", p.Nombre)
}

/* Ahora la interface ya esta conectada con cada estructura por medio de estas funciones, por lo que puedes crear una funcion para aquellas estructuras que sean de interface Animal, (Gato y Perro) */

func Presentarse (a Animal){
	a.Saludar() //Recuerden que Saludar pertenece a Animal
}






//Ahora ya podemos darle uso en main

func main(){
	gato := Gato{
		Nombre: "Susan"
	}
	perro := Perro {
		Nombre: "Chester"
	}

	Presentarse(perro)
	Presentarse(gato)

	/*Salida:
		Hola yo soy Susan
		Hola yo soy Chester
	*/
}

Espero haberme explicado, de cualquier manera le dejo el link que un usuario llamado PaoloTorregrosa: Go interfaces by GoByExample

Edgar de Jesus Mendoza Ortegon

student•

Esta un poco confuso este tema

Miguel ANGEL CULEBRAS MOSET

student•

Un poco confuso.

Paolo Donato Torregrosa Navarro

student•

Este tema puede resultar un poco comlejo pero aqui hay una info interesante https://gobyexample.com/interfaces En resumen una interfas es un conjunto de metodos que se pueden implementar de maneras diferentes dependiendo el struct, algo similar al polimorfismo de la POO

Daniel Zambrano

student•

Hola Paolo,

Agregando mi granito de arena, no considero que el ejemplo de polimofirsmo sea adecuado en este caso.  

Basado en lo que es SOLID. Polimorfismo viene siendo el principio de sustitución de liskov, dígase, si tu método recibe un objeto Animal Puedes usar como parámetro cualquier instancia que sea hijo de Animal  ,

Lo que esta explicando aquí con interfaces, viene siendo Dependency Inversion Principle, tus argumentos NO tienen que estas relacionados con la herencia. Pero aun puede ser usados como parámetros. Ejemplo: Una interfaz “Medible” con Peso, y un objeto “Silla” y otro “Perro” podrías decir que tienes 

CostoDeEnvio(obj Medible)

Si aun hay alguna duda con esto, mas que feliz de desarrollar mas la idea

Sergio Alexander Florez Galeano

student•

Comparto el código de mi ejercicio:

package main

import (
	"fmt"
)

type Course struct {
	Name string
	Slug string
	Skills [] string
}


func (p Course) Subscribe (name string) {
	fmt.Printf("La persona %s se ha registrado al curso %s\n", name, p.Name)
}


type Carrer struct {
	Course
}

func (p Carrer) Subscribe (name string) {
	fmt.Printf("La persona %s se ha registrado a la carrera %s\n", name, p.Name)
}

// An interface for Course and Carrer
type Organization interface {
	Subscribe(name string)
}

func callSubscribe(p Organization) {
	p.Subscribe("XergioAleX")
}


func main() {
	goCourse := Course{ Name: "Go", Slug: "go", Skills: [] string { "1", "2" } }
	goCarrer := new(Carrer)
	goCarrer.Name = "GoCarrer"
	goCarrer.Slug = "go"
	callSubscribe(goCourse)
	callSubscribe(goCarrer)
}

Todo el código del curso aquí: https://github.com/xergioalex/goBasics

Jose L. Figueroa

student•

Comparto mi ejercicio:

// ------------- main.go 
func main() {

	structs.InterfaceTest()
}


// -------------- interface.go

package structs

//Paltzi es una interface de PlatziCourse y PlatziCareer
type Platzi interface {
	Subscribe(name string)
}

func InterfaceTest() {
	platziCareer := PlatziCareer{
		Career: "Desarrollador GO",
		Course: PlatziCourse{Name: "Go", Slug: "/cursos/go", Teacher: PlatziInstructor{Name: "Yohan Graterol", ProfilePicture: "yohan-graterol.jpg", TeachesCourses: []string{"Intruducción a Go", "Go", "Bases de Datos con MongoDB"}}, Skills: []string{"Desarrollo Backend", "Desarrollo Templates"}},
	}
	platziCourse := PlatziCourse{Name: "Go", Slug: "/cursos/go", Teacher: PlatziInstructor{Name: "Yohan Graterol", ProfilePicture: "yohan-graterol.jpg", TeachesCourses: []string{"Intruducción a Go", "Go", "Bases de Datos con MongoDB"}}, Skills: []string{"Desarrollo Backend", "Desarrollo Templates"}}
	//platziCareer.Subscribe("JoseL")
	callSuscribe(platziCareer)
	callSuscribe(platziCourse)
	//fmt.Println(platziCareer)
}

func callSuscribe(p Platzi) {
	p.Subscribe("JoseL")
}

// ---------------- structs.go


//Struct PlatziCourse
type PlatziCourse struct {
	Name    string
	Slug    string
	Teacher PlatziInstructor
	Skills  []string
}

//Struct PlatziInstructor
type PlatziInstructor struct {
	Name           string
	ProfilePicture string
	TeachesCourses []string
}

//Subscribe es un método de PlatziCareer
func (p PlatziCourse) Subscribe(name string) {
	fmt.Printf("La persona %s se ha registrado al curso %s:\n", name, p.Name)
}

//Struct PlatziCareer es una estructura
type PlatziCareer struct {
	Career string
	Course PlatziCourse
}

//Subscribe es un método de PlatziCareer
func (p PlatziCareer) Subscribe(name string) {
	fmt.Printf("La persona %s se ha registrado a la carrera %s:\n", name, p.Career)
}

Juanse Calviño

student•

Hola Yohan, intenté replicar el ejercicio del video, pero en el archivo interface.go me dice que no reconoce las structs platziCourse y platziCareer. En qué parte del programa hay que decirles que pertenecen a la interface?
Saludos!

interface.go

package structs

// -- Interface Platzi para PlatziCourse y PlatziCareer

type Platzi interface {
	Suscribe(name string)
}

func InterfaceTest() {
	platziCourse := PlatziCourse{Name: "Go", Slug: "go", Skills: []string{"backend"}}
	platziCareer := new(PlatziCareer)
	platziCareer.Name = "Carrera Go"
	platziCareer.Slug = "go"
	callSuscribe(platziCareer)
	callSuscribe(platziCourse)
}

func callSuscribe(p Platzi) {
	p.Suscribe("Juan Sebastián Calviño")
}

structs.go

package structs

import "fmt"

// -- STRUCTS --

type PlatziCourse struct {
	Name   string
	Slug   string // url del curso
	Skills []string
}

type PlatziCareer struct {
	PlatziCourse // -> De esta manera decimos que PlatziCareer va a tomar todos los valores de PlatziCourse, como una herencia
}

// -- MÉTODO --

func (p PlatziCourse) Subscribe(name string) {
	fmt.Printf("El usuario %s, se ha inscripto al curso de %s\n", name, p.Name)
}

func (p PlatziCareer) Subscribe(name string) {
	fmt.Printf("El usuario %s, se ha inscripto a la carrera de %s\n", name, p.Name)
}

Juanse Calviño

student•

Este el error:

structs\interface.go:14: cannot use platziCareer (type *PlatziCareer) as type Platzi in argument to callSuscribe:
*PlatziCareer does not implement Platzi (missing Suscribe method)
structs\interface.go:15: cannot use platziCourse (type PlatziCourse) as type Platzi in argument to callSuscribe:
PlatziCourse does not implement Platzi (missing Suscribe method)

Diego Forero

Team Platzi•

Tienes un error de digitación. es Subscribe y estas llamando como Suscribe

Mario Ruíz

student•

tranquilos es lo mas confuso de todos los lenguajes es normal

David Arce

student•

Muy confusa esta clase, el problema para mí es que se tomó muy mal un ejemplo base para explicar cómo es el funcionamiento de las interfaces.

En resumen y para que quede claro una interface en la mayoría de los lenguajes nos sirve como un contrato en el cual objetos o en este caso structs pueden implementarla según su propia lógica o comportamiento.

El ejemplo práctico en go es la interface geometry que define una firma de métodos que se pueden implementar en figuras como circle o rect

type geometry interface {
    area() float64
    perim() float64
}

Luego podemos implementar estos métodos:

type rect struct {
    width, height float64
}
type circle struct {
    radius float64
}

// implement geometry on rects.
func (r rect) area() float64 {
    return r.width * r.height
}
func (r rect) perim() float64 {
    return 2*r.width + 2*r.height
}

//The implementation for circles.

func (c circle) area() float64 {
    return math.Pi * c.radius * c.radius
}
func (c circle) perim() float64 {
    return 2 * math.Pi * c.radius
}

Y podemos definir una función que sirva para ambas structs

func measure(g geometry) {
    fmt.Println(g)
    fmt.Println(g.area())
    fmt.Println(g.perim())
}
func main() {
    r := rect{width: 3, height: 4}
    c := circle{radius: 5}

    measure(r)
    measure(c)
}

Joshua Mora

student•

No entiendo nada estoy muy confundido, y con sus ejemplos en mi codigo tengo errores que no se solucionar

William Martinez

student•

Puede ser un tema muy dificil sobre todo si el lenguaje no es orientado a objetos. Pero hay que entender que las interfaces nos pueden ayudar a definir un comportamiento en comun que puedan tener diferentes structs. Como por ejemplo lo siguiente:

package main

import "fmt"

// Song struct
type Song struct {
	Name   string
	Artist    string
}

// Video struct
type Video struct {
	Name     string
	Duration int
}

// Media interface
type Media interface {
	Play()
}

// Play function to play the song
func (s Song) Play() {
	fmt.Printf("Playing song %s... \n", s.Name)
}

// Play function to play the video
func (m Video) Play() {
	fmt.Printf("Playing video %s... \n", m.Name)
}

// PlayMedia the media content
func PlayMedia(m Media) {
	m.Play()
}

func main() {
	song := Song{Name: "La cancion", Artist: "Bad Bunny"}
	video := Video{Name: "Top lenguajes de programacion", Duration: 830}

	PlayMedia(song)
	PlayMedia(video)
}

Tanto la estructura Song como Video tienen una funcion en comun que es Play, entonces podemos usar una interface llamada Media que agrupe las funciones en comun y la utilicemos con structs que tengan esa funcion (como Song y Video).

Alexander Armúa Abregu

student•

Por si les interesa modificar un valor dentro de la estructura, Tienen que hacerlo haciendo uso de punteros. Ejemplo:

type Heroe struct {
	Nombre string
	Clase string
	Skills []string
}

func (p *Heroe) NewSkill(skill string) {
	p.Skills = append(p.Skills, skill)
	fmt.Printf(&quot;El heroe %s ha aprendido la skill %s\n&quot;, p.Nombre, skill)
}