Creando la Interfaz Animal

Clase 21 de 42 • Curso Práctico de Go: Creación de un Servidor Web

Clase anteriorSiguiente clase

William Rodriguez

student•

Interesante el concepto de polimorfismo en Go con las interfaces.

Jecsham Castillo

student•

Enzo Aliatis

student•

package main

import &quot;fmt&quot;

type animal interface {
	makeSound() string
}

type dog struct{}

type cat struct{}

func (d dog) makeSound() string {
	return &quot;Waow waow&quot;
}

func (c cat) makeSound() string {
	return &quot;Miau&quot;
}

func animalMakeSound(a animal) {
	fmt.Println(a.makeSound())
}

func main() {
	cafu := dog{}
	sisa := cat{}

	animalMakeSound(cafu)
	animalMakeSound(sisa)

}

Jean Nuñez

student•

Buen codigo limpio y bien estructurado

Carlos Javier Bazan Huaman

student•

esa implementacion implicita esta cool!., no sabia que se podia hacer eso con las interfaces de ese modo.

Juan Pablo Rodríguez Morales

student•

¿no puede llegar a ser confuso? Es decir, qué pasa si en el mismo hay dos interfaces con el mismo método a implementar

Kevin Bueno

student•

Hola, para entender esto es importante recordar un concepto clave en la programación orientada a objetos llamado Polimorfismo que posibilita nombrar varios métodos de la misma forma y ejecutar un comportamiento diferente dependiendo el parámetro envíado.

Daniel G Perico Sánchez

student•

Para los amantes de Avatar cómo yo:

package main

import "fmt"

type maestro interface {
	presentacion() string
}

type agua struct {
	nombre string
}

type tierra struct {
	nombre string
}

type fuego struct {
	nombre string
}

type aire struct {
	nombre string
}

func (a agua) presentacion() string {
	returnString := "Mi nombre es " + a.nombre + " y soy un maestro agua."
	return returnString
}

func (t tierra) presentacion() string {
	returnString := "Mi nombre es " + t.nombre + " y soy un maestro tierra."
	return returnString
}

func (f fuego) presentacion() string {
	returnString := "Mi nombre es " + f.nombre + " y soy un maestro fuego."
	return returnString
}

func (ai aire) presentacion() string {
	returnString := "Mi nombre es " + ai.nombre + " y soy un maestro aire."
	return returnString
}

func presentarMaestro(m maestro) {
	fmt.Println(m.presentacion())
}

func main() {
	a := agua{
		nombre: "Katara",
	}
	t := tierra{
		nombre: "Toph",
	}
	f := fuego{
		nombre: "Zuko",
	}
	aa := aire{
		nombre: "Aang",
	}

	presentarMaestro(a)
	presentarMaestro(t)
	presentarMaestro(f)
	presentarMaestro(aa)
}

Luis Gustavo Vargas Reynoso

student•

Nombres de interfaz

Por convención, las interfaces de un método se nombran por el nombre del método más un sufijo -er o una modificación similar para construir un nombre de agente: Reader, Writer, Formatter, CloseNotifier etc.

Hay varios de esos nombres y es productivo honrarlos y los nombres de función que capturan. Read, Write, Close, Flush, String, etc. tienen firmas y significados canónicos. Para evitar confusiones, no le dé a su método uno de esos nombres a menos que tenga la misma firma y significado. Por el contrario, si su tipo implementa un método con el mismo significado que un método en un tipo conocido, asígnele el mismo nombre y firma; llame a su método de string-converter String not ToString.

https://go.dev/doc/effective_go#interface-names

Jaime Andres Valencia Gaviria

student•

un poco tosco el hecho de las intefaces no se implementen de manera explicita, puede llevar a varias confusiones , existe alguna forma de hacerlo explicito ??

Juan David Rueda Quiroga

student•

package main

import "fmt"

type animal interface {
	move() string
}

type dog struct {

}

type fish struct {

}

type bird struct {

}

func (dog) move() string {
	return "I'm dog and i walk"
}

func (fish) move() string {
	return "I'm fish and i'm swimming"
}

func (bird) move() string {
	return "I'm bird and i'm fling"
}

func moveAnimal(a animal) {
	fmt.Println(a.move())
}

func main() {
	d := dog{}
	moveAnimal(d)
	f := fish{}
	moveAnimal(f)
	b := bird{}
	moveAnimal(b)
}

fabio andres zamora osorio

student•

No entendi el beneficio de ahorrar codigo usando interfaces con el ejemplo que explico el profesor ya que en dicho ejemplo sin necesidad de crear la interface se puede ahorrar codigo si solo se crean 3 metodos donde cada metodo contenga el string de lo que hace el animal con la impresion de ese string, osea: . ¿Porque escribir el string de lo que hace el animal en un metodo y escribir la impresion de ese string en otro metodo, osea porque escribir 2 metodos por animal, no seria mejor que por cada animal escribir un solo metodo con el string y con la impresion de ese string y asi ahorrarnos escribir 3 funciones o ahorrarnos escribir la interface?

Leonardo Valdivieso

student•

Con la Interface se crea un contrato que dice que el objeto que recibes cumple esa interface, entonces puedes confiar que conoce un método en particular. Entonces tu función puede recibir cualquier objeto que ejecute ese método,. Luego podría tener una lista de objetos diferentes que ejecutan ese método. Tu función se vuelve más genérica, ahorras código y usas menos los IF.

Victor Hugo Cruz Carballo

student•

package main

import "fmt"

type animal interface {
	mover() string
}

type perro struct{}
type ave struct{}
type pez struct{}

func (perro) mover() string {
	return "soy un perro y estoy caminando"
}
func (ave) mover() string {
	return "soy un ave y estoy volando"
}

func (pez) mover() string {
	return "soy un pez y estoy nadando"
}

func moverAnimal(a animal) {
	fmt.Println(a.mover())
}

func main() {
	p := perro{}
	moverAnimal(p)
	a := ave{}
	moverAnimal(a)
	pe := pez{}
	moverAnimal(pe)
}

Carlos Nassif Trejo Garcia

student•

package main

import "fmt"

type animal interface {
	mover() string
}

type perro struct {
}

type pez struct {
}

type pajaro struct {
}

func (perro) mover() string {
	return "Soy un perro y camino"
}

func (pez) mover() string {
	return "Soy un pez y nado"
}

func (pajaro) mover() string {
	return "Soy un pajaro y estoy nadando"
}


func moverAnimal(a animal) {
	fmt.Println(a.mover())
}

func main() {
	p := perro{}
	pe := pez{}
	pa := pajaro{}

	moverAnimal(p)
	moverAnimal(pe)
	moverAnimal(pa)
	
}

Usuario anónimo

user•

genial :) estoy atento cuando hable de los package.. para de alguna manera ordenar lo struct en distintos paquetes :)

Samuel R.

student•

Añadí a la implementación, un slice de animales, así con un for range podemos usar la función una sola vez y simplificar más el código


package main

import "fmt"

type animal interface {
	move() string
}

type dog struct {
}

type fish struct {
}

type bird struct {
}

// func (d dog) walk() string {
// 	return "I am a dog and walk"
// }

// func (f fish) swim() string {
// 	return "I am a fish and swim"
// }

// func (b bird) fly() string {
// 	return "I am a bird and fly"
// }

func (d dog) move() string {
	return "I am a dog and walk"
}

func (f fish) move() string {
	return "I am a fish and swim"
}

func (b bird) move() string {
	return "I am a bird and fly"
}

func move(a animal) {
	fmt.Println(a.move())
}

// func moveDog(d dog) {
// 	fmt.Println(d.walk())
// }

// func moveFish(f fish) {
// 	fmt.Println(f.swim())
// }

// func moveBird(b bird) {
// 	fmt.Println(b.fly())
// }

func main() {
	d := dog{}
	// moveDog(d)
	move(d)
	f := fish{}
	// moveFish(f)
	move(f)
	b := bird{}
	// moveBird(b)
	move(b)

	animals := []animal{
		d,
		f,
		b,
	}
	fmt.Println(animals)
	for _, animal := range animals {
		move(animal)
	}
}

Jhoel Santiago Soncco Florez

student•

package main

import "fmt"

type animal interface {
	move() string
}

type animalType struct {
	name string
	action string
}
func (at animalType) move() string {
	return "I'm a " + at.name + " and i " + at.action
}

func moveAnimal(a animal) {
	fmt.Println(a.move())
}

func main() {
	d := animalType{
		name: "dog",
		action: "walk",
	}
	moveAnimal(d)
	f := animalType{
		name: "fish",
		action: "swim",
	}
	moveAnimal(f)
	b := animalType{
		name: "bird",
		action: "fly",
	}
	moveAnimal(b)
}

Fernando Alberto Velasquez Aguilera

student•

ackage main

import (
	"fmt"
)

type animal interface {
	raza() string
}

type perro struct{}
type gato struct{}
type caballo struct{}

func (p perro) raza() string {
	return "Pitbull"
}

func (c caballo) raza() string {
	return "Mustang"
}

func (g gato) raza() string {
	return "Savannah"
}

func razaAnimal(a animal) {
	fmt.Println(a.raza())
}

func main() {
	vandalo := perro{}
	michin := caballo{}
	trueno := gato{}

	razaAnimal(vandalo)
	razaAnimal(michin)
	razaAnimal(trueno)
	
}

Fernando Alberto Velasquez Aguilera

student•

package main

import (
	"fmt"
)

type animal interface {
	raza() string
}

type perro struct{}
type gato struct{}
type caballo struct{}

func (p perro) raza() string {
	return "Pitbull"
}

func (c caballo) raza() string {
	return "Mustang"
}

func (g gato) raza() string {
	return "Savannah"
}

func razaAnimal(a animal) {
	fmt.Println(a.raza())
}

func main() {
	vandalo := perro{}
	michin := caballo{}
	trueno := gato{}

	razaAnimal(vandalo)
	razaAnimal(michin)
	razaAnimal(trueno)
	
}```

Creando la Interfaz Animal

Introducción a Go

Mi primer programa en Go

Instalación en Mac y Windows

Instalar VS Code

Comandos básicos de Go

Analizando un programa en Go

Nuestra Primera Aplicación Go

Descripción del proyecto 1: Calculadora

Leer inputs desde la consola

Manejo de errores y uso de If

Switch

Lista de Tareas

Structs y Receivers

Descripción del proyecto 2: Lista de Tareas

Structs para Lista de Tareas

Punteros

Punteros en Structs

Uso de Slices

Ciclo For

Implementar For en Struct

Interfaces

¿Qué es una interfaz?

Maps

¿Por qué las Interfaces?

Creando la Interfaz Animal

Imprimiendo el contenido de una Página Web usando Interfaces

Goroutines y Channels

Introducción al problema de la Concurrencia

GoRoutines

Channels

Implementación de Goroutines y channels

Construyendo un Servidor Web

Ciclos While y For

Descripción de Servidor Web

Creando el Servidor

Manejando rutas en backend

¿Qué es un Middleware?

Manejando Request HTTP

Asignando Rutas HTTP

Agregando Middlewares

Agregando Multiples Middlewares

Agregando otro Middleware

Manejando POST

Manejando Modelos y JSON

Respondiendo Request JSON

Go Modules creando nuestro primer módulo en Go

Implementando nuestro primer módulo en Go

Conclusiones del Curso y siguientes pasos