No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Interfaces

10/30
Recursos

Aportes 11

Preguntas 4

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

o inicia sesi贸n.

Les comparto mis implementaciones de getMessage para FullTimeEmployee y TemporaryEmployee 馃槂:

func (ftEmployee FullTimeEmployee) getMessage() string {
	return fmt.Sprintf("\nFull Time Employee\nid: %d name: %s age: %d endDate: %s",
		ftEmployee.id,
		ftEmployee.name,
		ftEmployee.age,
		ftEmployee.endDate)
}
func (tEmployee TemporaryEmployee) getMessage() string {
	return fmt.Sprintf("\nTemporary Employee\nid: %d name: %s age: %d taxRate: %d",
		tEmployee.id,
		tEmployee.name,
		tEmployee.age,
		tEmployee.taxRate)
}

En lenguajes como Typescript o Java es necesario definir los m茅todos de la interfaz para poder implementarla y la implementaci贸n es expl铆cita.
En cambio en Go, es suficiente definir los m茅todos para implementar la interfaz y la implementaci贸n es impl铆cita.
En el polimorfismo se utiliza una interfaz (o una clase base) para determinar en tiempo de ejecuci贸n el m茅todo a utilizar, accedi茅ndolo por medio de la interfaz en vez de hacerlo a trav茅s de un objeto en particular, porque en este 煤ltimo caso el m茅todo se determina en tiempo de compilaci贸n (esto no es polimorfismo).

// no se conoce p hasta el momento en que 
// se ejecuta esta funci贸n
// podr铆a ser un FullTimeEmployee
// o un TemporaryEmployee
func getMessage(p PrintInfo) {
  fmt.Println(p.getMessage)
}

// aqu铆 ya se conoce el m茅todo a usar
// antes de compilar
ftEmployee.getMessage()

Entonces con polimorfismo, podr铆as por ejemplo, estar recibiendo desde una BD o un JSON desde un front, los datos de un empleado en tiempo de ejecuci贸n y determinar en ese momento cual es el m茅todo apropiado para ese empleado en particular.

El tipado de Go respecto de las interfaces es una especie de duck typing. Como regla nmemot茅cnica: si camina como un pato y hace cu谩c como un pato, entonces debe ser un pato. La diferencia entre duck typing y el tipado en Go, es que en Go el chequeo sucede en tiempo de compilaci贸n, es tipado est谩tico. Es por esto que lo llaman 鈥渢ipado estructural鈥, el chequeo le da importancia a la estructura.

Go no implementa interfaces de manera explicita sino de manera impl铆cita.

Apuntes y c贸digo:

  • Diferentes lenguajes de programaci贸n utilizan sintaxis explicita para decir que una clase implementa un interfaz
  • Go lo hace de manera impl铆cita lo que permite la re utilizaci贸n de c贸digo y polimorfismo
package main

import "fmt"

type Person struct {
	name string
	age  int
}

type Employee struct {
	id int
}

// De esta manera aplicamos la composicion sobre la herencia
type FullTimeEmployee struct {
	Person
	Employee
	endDate string
}

type TemporatyEmployee struct {
	Person
	Employee
	taxRate int
}
// Creamos la interfaz
type PrintInfo interface {
	getMessage() string
}
// Implementamos la interfaz
func (ftEmployee FullTimeEmployee) getMessage() string {
	return "Full Time Employee"
}

func (tEmployee TemporatyEmployee) getMessage() string {
	return "Temporary Employee"
}
// Creamos el metodo de la interfaz
func getMessage(p PrintInfo) {
	fmt.Println(p.getMessage())
}

func main() {
	ftEmployee := FullTimeEmployee{}
	ftEmployee.name = "Benjamin"
	ftEmployee.age = 20
	ftEmployee.id = 1
	fmt.Printf("%v\n", ftEmployee)
	tEmployee := TemporatyEmployee{}
	getMessage(tEmployee)
	getMessage(ftEmployee)
}

yo no conozco typescript, por lo que me perdi en esta explicaci贸n.

Siento muy forzado go para la OOP, pero siento que se puede mantener la limpieza si todo lo llevamos a un archivo aparte.

package main

import "fmt"

type Person struct {
	name string
	age  int
}

type Employee struct {
	id int
}

// Inheritance tipo anonimo
type FullTimeEmployee struct {
	Person
	Employee
	endDate string
}

type TemproaryEmployee struct {
	Person
	Employee
	taxRate float64
}

type PrintInfo interface {
	getMessage() string
}

// Composicion sobre herencia
func (ft FullTimeEmployee) getMessage() string {
	return fmt.Sprintf("Hi %s, you are %d years old. And you are a full time employee", ft.name, ft.age)
}

func (te TemproaryEmployee) getMessage() string {
	return fmt.Sprintf("Hi %s, you are %d years old. And you are a temprary employee", te.name, te.age)
}

func GetMessage(pi PrintInfo) {
	fmt.Println(pi.getMessage())
}

func main() {
	f := FullTimeEmployee{}
	f.name = "John"
	f.age = 30
	f.id = 1
	f.endDate = "2019-01-01"
	fmt.Printf("%+v\n", f)

	t := TemproaryEmployee{}
	t.name = "Mary"
	t.age = 25
	t.id = 2
	t.taxRate = 0.25
	fmt.Printf("%+v\n", t)

	GetMessage(f)
	GetMessage(t)
}

Genial lo que he podido recordar de TS., pero para quienes no conocen de JS o TS, siento podr铆a ser un poco engorroso tener que ver media clase de un lenguaje al cual no le est谩n apuntando. Por lo dem谩s, muy bien explicado.

package main

import "fmt"

type Person struct {
	name string
	age  uint8
	sex  string
}

type PrintInfo interface {
	getMessage() string
}
type Employee struct {
	id uint64
}

type FullTimeEmployee struct {
	Person
	Employee
	endTime int
}

func (ftEmployee FullTimeEmployee) getMessage() string {
	return "Este es un fulltimeEmployee"
}

type TemporaryEmployee struct {
	Person
	Employee
	taxRate string
}

func (tEmployee TemporaryEmployee) getMessage() string {
	return "Este es un TemporaryEmployee"
}

func getMessage(p PrintInfo) {
	fmt.Printf("%+v\n", p.getMessage())
}

func main() {
	ftEmployee := FullTimeEmployee{}
	ftEmployee.name = "Carlos"
	ftEmployee.age = 25
	ftEmployee.id = 1
	ftEmployee.sex = "hombre"
	fmt.Printf("%+v\n", ftEmployee)

	tEmployee := TemporaryEmployee{}
	fmt.Printf("%+v\n", tEmployee)

	getMessage(ftEmployee)
	getMessage(tEmployee)

}

codigo:

package main

import "fmt"

type Person struct {
	name string
	age  int
}

type Employee struct {
	id int
}

type FullTimeEployee struct {
	Person
	Employee
	endDate string
}

// metodo de FullTimeEmployee
func (ftEmploye FullTimeEployee) getMessage() string {
	return "Full Time Employe"
}

type TemporaryEmployee struct {
	Person
	Employee
	taxRate int
}

// Metodo de Temporary Employee
func (tEmploye TemporaryEmployee) getMessage() string {
	return "Temporary Employe"
}

// Interface
type PrintInfo interface {
	getMessage() string
}

func getMessage(p PrintInfo) {
	fmt.Println(p.getMessage())
}

func main() {
	ftEmployee := FullTimeEployee{}
	ftEmployee.id = 1
	ftEmployee.name = "Maria"
	ftEmployee.age = 27
	//fmt.Printf("%v", ftEmployee)

	tEmployee := TemporaryEmployee{}
	getMessage(ftEmployee)
	getMessage(tEmployee)

}