No tienes acceso a esta clase

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

Herencia

9/30
Recursos

Aportes 18

Preguntas 2

Ordenar por:

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

Go no permite la herencia, go utiliza la composicion.
la composicion, a diferencia de la herencia, no es una clase hija de鈥 sino que contiene los metodos de las clases indicadas.

codigo:

package main

import "fmt"

type Person struct {
	name string
	age  int
}

type Employee struct {
	id int
}

type FullTimeEployee struct {
	Person
	Employee
}

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

La siguiente funci贸n es un m茅todo para que FullTimeEmployee imprima sus atributos de forma m谩s 鉁 bonita 鉁:

func (employee FullTimeEmployee) String() string {
	return fmt.Sprintf("\nid: %d, name: %s, age: %d ", employee.id, employee.name, employee.age)
}
  • No entiendo por que usa otros lenguajes para explicar, explica todo en Golang, vengo aprender GO, no typescript, para eso me voy al curso de typescript, Entiendo que quiere explicar las diferencias, pero cuando yo explico python no voy con ejemplos de Java, se confunde la gente y se enredan mas, los primeros 7min es de typescript, increible

Cuando se tienen receiver functions asociadas a un struct y se forma otro struct a partir de este, los m茅todos tambi茅n funcionan con el nuevo struct.
Creo que esto se parece m谩s a la herencia en Go hablando de m茅todos.
Y a煤n contando con esa herencia de m茅todos puedo reescribir la receiver function en el nuevo struct solo creando una funci贸n con el mismo nombre y recibiendo el struct. As铆 tendr铆a polimorfismo.

package main

import "fmt"

type Person struct {
	Name string
	Age int
}

type Employee struct {
	Person
	Position string
	Salary int
}

func (p Person) SayHello() {
	fmt.Printf("Hi, my name is %s\n", p.Name)
}

func main() {
	me := Person{Name: "Edwin", Age: 30}
	developer := Employee{
		Person: Person{Name: "Lorena", Age: 27},
		Position: "Developer",
		Salary: 2000,
	}

	person.SayHello() // Hi, my name is Edwin
	developer.SayHello() // Hi, my name is Lorena
}

Ahora reescribiendo el m茅todo SayHello

package main

import "fmt"

type Person struct {
	Name string
	Age int
}

type Employee struct {
	Person
	Position string
	Salary int
}

func (p Person) SayHello() {
	fmt.Printf("Hi, my name is %s\n", p.Name)
}

func (e Employee) SayHello() {
	fmt.Printf("Hi, I am a %s and my name is %s\n", e.Position,  e.Name)
}

func main() {
	me := Person{Name: "Edwin", Age: 30}
	developer := Employee{
		Person: Person{Name: "Lorena", Age: 27},
		Position: "Developer",
		Salary: 2000,
	}

	person.SayHello() // Hi, my name is Edwin
	developer.SayHello() // Hi, I am a developer and my name is Lorena
}

Podemos usar esta funcion como un constructor

func CreateFullTimeEmployee(name string, age int, id int) *FullTimeEmployee {
	newEmployee := FullTimeEmployee{}
	newEmployee.name = name
	newEmployee.age = age
	newEmployee.id = id

	return &newEmployee
}
func main() {
	ftEmployee := CreateFullTimeEmployee("Alex", 20, 0)
	fmt.Println(*ftEmployee)
}

definitivamente platzi es horrible para la teoria鈥

De hecho en el ejemplo la funci贸n que acepta una persona, si se puede ocupar, por el empleado a tiempo completa. ya que Persona es parte de FullTimeEmployee, simplemente hay que usar persona de FullTimeEmployee.

package main

import (
	"fmt"
)

type Person struct {
	name string
	age  int
}

type Employee struct {
	id int
}
type FullTimeEmployee struct {
	Person
	Employee
}

func GetMessage(p Person) {
	fmt.Printf("%s, tu edad es %d", p.name, p.age)
}

func main() {
	var ftEmployee FullTimeEmployee
	ftEmployee.age = 36
	ftEmployee.id = 1233
	ftEmployee.name = "Jose"
	GetMessage(ftEmployee.Person)
}```
package main

import "fmt"

type Person struct {
	name string
	age  int
}

type Employee struct {
	id int
}

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

// Composicion sobre herencia
func GetMessage(p Person) string {
	return fmt.Sprintf("Hi %s, you are %d years old", p.name, p.age)
}

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

	fmt.Println(GetMessage(f))
}

Aqui implemete un cosntructor y un metodo que regresa un informacion ```js package main import "fmt" type Person struct { name string age int } type Employee struct { id int } // Composicion de herencia, se agrega el tipo de objeto type FullTimeEmployee struct { Person Employee } //Metodo func NewFullTimeEmployee(name string, age int, id int) *FullTimeEmployee { return &FullTimeEmployee{ Person: Person{ name: name, age: age, }, Employee: Employee{ id: id, }, } } func (ftEmployee *FullTimeEmployee) GetMesagge() { fmt.Printf("FullTimeEmployee's Name :%s with a age %d and him/her id is %d\n", ftEmployee.name, ftEmployee.age, ftEmployee.id) } func main() { ft := NewFullTimeEmployee("Axel", 22, 1) ft.GetMesagge() } ```
Aqui implemete un constructor y un metodo donde regresa informacion ```js package main import "fmt" type Person struct { name string age int } type Employee struct { id int } // Composicion de herencia, se agrega el tipo de objeto type FullTimeEmployee struct { Person Employee } //Metodo func NewFullTimeEmployee(name string, age int, id int) *FullTimeEmployee { return &FullTimeEmployee{ Person: Person{ name: name, age: age, }, Employee: Employee{ id: id, }, } } func (ftEmployee *FullTimeEmployee) GetMesagge() { fmt.Printf("FullTimeEmployee's Name :%s with a age %d and him/her id is %d\n", ftEmployee.name, ftEmployee.age, ftEmployee.id) } func main() { ft := NewFullTimeEmployee("Axel", 22, 1) ft.GetMesagge() } ```package main import "fmt" type Person struct {聽 聽 name string聽 聽 age 聽int} type Employee struct {聽 聽 id int} // Composicion de herencia, se agrega el tipo de objetotype FullTimeEmployee struct {聽 聽 Person聽 聽 Employee} //Metodo func NewFullTimeEmployee(name string, age int, id int) \*FullTimeEmployee {聽 聽 return \&FullTimeEmployee{聽 聽 聽 聽 Person: Person{聽 聽 聽 聽 聽 聽 name: name,聽 聽 聽 聽 聽 聽 age: 聽age,聽 聽 聽 聽 },聽 聽 聽 聽 Employee: Employee{聽 聽 聽 聽 聽 聽 id: id,聽 聽 聽 聽 },聽 聽 }} func (ftEmployee \*FullTimeEmployee) GetMesagge() {聽 聽 fmt.Printf("FullTimeEmployee's Name :%s 聽with a age %d and him/her id is %d\n", ftEmployee.name, ftEmployee.age, ftEmployee.id)}func main() {聽 聽 ft := NewFullTimeEmployee("Axel", 22, 1)聽 聽 ft.GetMesagge()}
Aqui implemete el constructor y un metodopackage main import "fmt" type Person struct {聽 聽 name string聽 聽 age 聽int} type Employee struct {聽 聽 id int} // Composicion de herencia, se agrega el tipo de objetotype FullTimeEmployee struct {聽 聽 Person聽 聽 Employee} //Metodo func NewFullTimeEmployee(name string, age int, id int) \*FullTimeEmployee {聽 聽 return \&FullTimeEmployee{聽 聽 聽 聽 Person: Person{聽 聽 聽 聽 聽 聽 name: name,聽 聽 聽 聽 聽 聽 age: 聽age,聽 聽 聽 聽 },聽 聽 聽 聽 Employee: Employee{聽 聽 聽 聽 聽 聽 id: id,聽 聽 聽 聽 },聽 聽 }} func (ftEmployee \*FullTimeEmployee) GetMesagge() {聽 聽 fmt.Printf("FullTimeEmployee's Name :%s 聽with a age %d and him/her id is %d\n", ftEmployee.name, ftEmployee.age, ftEmployee.id)}func main() {聽 聽 ft := NewFullTimeEmployee("Axel", 22, 1)聽 聽 ft.GetMesagge()} ```js package main import "fmt" type Person struct { name string age int } type Employee struct { id int } // Composicion de herencia, se agrega el tipo de objeto type FullTimeEmployee struct { Person Employee } //Metodo func NewFullTimeEmployee(name string, age int, id int) *FullTimeEmployee { return &FullTimeEmployee{ Person: Person{ name: name, age: age, }, Employee: Employee{ id: id, }, } } func (ftEmployee *FullTimeEmployee) GetMesagge() { fmt.Printf("FullTimeEmployee's Name :%s with a age %d and him/her id is %d\n", ftEmployee.name, ftEmployee.age, ftEmployee.id) } func main() { ft := NewFullTimeEmployee("Axel", 22, 1) ft.GetMesagge() } ```
Aqui implemente el constructor ```js package main import "fmt" type Person struct { name string age int } type Employee struct { id int } // Composicion de herencia, se agrega el tipo de objeto type FullTimeEmployee struct { Person Employee } func newFullTimeEmployee(name string, age int, id int) *FullTimeEmployee { return &FullTimeEmployee{ Person: Person{ name: name, age: age, }, Employee: Employee{ id: id, }, } } func main() { ft := newFullTimeEmployee("Axel", 22, 1) fmt.Println(*ft) } ```package main import "fmt" type Person struct {聽 聽 name string聽 聽 age 聽int} type Employee struct {聽 聽 id int} // Composicion de herencia, se agrega el tipo de objetotype FullTimeEmployee struct {聽 聽 Person聽 聽 Employee} func newFullTimeEmployee(name string, age int, id int) \*FullTimeEmployee {聽 聽 return \&FullTimeEmployee{聽 聽 聽 聽 Person: Person{聽 聽 聽 聽 聽 聽 name: name,聽 聽 聽 聽 聽 聽 age: 聽age,聽 聽 聽 聽 },聽 聽 聽 聽 Employee: Employee{聽 聽 聽 聽 聽 聽 id: id,聽 聽 聽 聽 },聽 聽 }} func main() {聽 聽 ft := newFullTimeEmployee("Axel", 22, 1)聽 聽 fmt.Println(\*ft)}

Yo pienso que herencia es un problema de dise帽o, aunque parece f谩cil en sintaxis para el programador.
Ejemplo, si escribi茅ramos el c贸digo ej. de java que usa herencia en C y tuvi茅ramos que implementar la herencia a mano, podemos ver la magnitud de la ineficiencia de usar herencia muy f谩cil, tendr铆amos 2000 punteros, punteros de punteros que apuntan a punteros, mallocs/free鈥檚 de memoria y uniones
Al usar composici贸n y agregaci贸n se evitan esos problemas desde el principio y esto est谩 disponible en todos los lenguajes, incluso Orientados a objetos.

Excelente clase!!! Muy clara la distinci贸n entre la herencia cl谩sica en otros lenguajes y la implementaci贸n que realiza golang por medio de la composici贸n.

herencia: la clase hija ES la clase padre
composici贸n: la clase hija TIENE la(s) clase(s) padre

package main

import "fmt"

type Person struct {
	name string
	age  uint8
	sex  string
}

type Employee struct {
	id uint64
}

type FullTimeEmployee struct {
	Person
	Employee
}

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

Les dejo lo que seria el m茅todo constructor de FullTimeEmployee:

func newFullTimeEmployee(name string, age int, id int) *FullTimeEmployee {
	return &FullTimeEmployee{
		Person{Name: name, Age: age},
		Employee{Id: id},
	}
}

El ejemplo final se puede llegar a hacer pero pasando de que struct viene dicho dato. Ejemplo

func GetMessage(p Person, e Employee) {
	fmt.Printf("El Id es %d %s with age %d\n", e.id, p.name, p.age)
}
func main () {
GetMessage(ftEmployee.Person, ftEmployee.Employee)
}

Para hacer funcionar el m茅todo GetMessage, he probado que pueden pasar la persona que corresponde a ese un empleado, de esta forma:

GetMessage(ftEmployee.Person)