Go Academy · Lección

Composición frente a herencia

La filosofía de diseño de Go

Composición frente a herencia es una lección gratuita de Go Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Go Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Go Academy incluye 4 lecciones en total.

Filosofía de diseño de Go

Go prescinde deliberadamente de la herencia de clases. El enfoque idiomático es la composición: cree comportamiento combinando tipos e interfaces pequeños.

Por qué no usar herencia

Las jerarquías de herencia profundas son frágiles: un cambio en una clase base se propaga de forma impredecible. La composición mantiene las relaciones explícitas y flexibles.

Tiene-un en lugar de Es-un

En lugar de modelar «un Manager es un Employee», modele «un Manager tiene los datos y las capacidades de un Employee» mediante embedding o campos.

package main

import "fmt"

type Employee struct{ Name string }

func (e Employee) Work() string { return e.Name + " works" }

type Manager struct {
	Employee
	Reports int
}

func main() {
	m := Manager{Employee{"Lin"}, 3}
	fmt.Println(m.Work(), "-", m.Reports, "reports")
}

Programe contra interfaces

Defina el comportamiento con interfaces pequeñas y, después, acéptelas. Las implementaciones son intercambiables y fáciles de sustituir o simular.

package main

import "fmt"

type Notifier interface{ Notify(msg string) }

type Email struct{}

func (Email) Notify(msg string) { fmt.Println("email:", msg) }

func alert(n Notifier, m string) { n.Notify(m) }

func main() {
	alert(Email{}, "deploy done")
}

Sustituir implementaciones

Como la función depende de una interfaz, puede pasarle cualquier implementación sin modificar la función.

package main

import "fmt"

type Notifier interface{ Notify(msg string) }

type Email struct{}
type SMS struct{}

func (Email) Notify(m string) { fmt.Println("email:", m) }
func (SMS) Notify(m string)   { fmt.Println("sms:", m) }

func alert(n Notifier, m string) { n.Notify(m) }

func main() {
	alert(Email{}, "hi")
	alert(SMS{}, "hi")
}

Combinar comportamientos

Incruste varios componentes pequeños para ensamblar un tipo con muchas funcionalidades a partir de piezas independientes y fáciles de probar.

package main

import "fmt"

type Logger struct{}

func (Logger) Log(s string) { fmt.Println("log:", s) }

type Cache struct{ data map[string]string }

func (c Cache) Get(k string) string { return c.data[k] }

type Service struct {
	Logger
	Cache
}

func main() {
	s := Service{Cache: Cache{data: map[string]string{"k": "v"}}}
	s.Log("started")
	fmt.Println(s.Get("k"))
}

Inyección de dependencias

Pase las dependencias, como interfaces, a los constructores en lugar de codificarlas directamente. Esta es la composición aplicada a la conexión de componentes.

package main

import "fmt"

type Store interface{ Save(s string) }

type MemStore struct{ items []string }

func (m *MemStore) Save(s string) { m.items = append(m.items, s) }

type App struct{ store Store }

func NewApp(s Store) *App { return &App{store: s} }

func main() {
	app := NewApp(&MemStore{})
	app.store.Save("x")
	fmt.Println("saved")
}

Las interfaces pequeñas triunfan

Cuanto más pequeña es una interfaz, más tipos la satisfacen y más fácil es probarlos. Cuanto más grande es la interfaz, más débil es la abstracción.

Evitar la clase base frágil

Sin herencia, no hay una clase base que pueda romperse. Cada pieza compuesta evoluciona de forma independiente, lo que reduce el acoplamiento.

Acepte interfaces, devuelva structs

Una pauta habitual en Go: las funciones aceptan interfaces, que ofrecen entradas flexibles, y devuelven structs concretos, que ofrecen salidas claras y utilizables.

Lista de comprobación de la composición

Modele tiene-un, no es-un
Incruste componentes pequeños
Dependa de interfaces pequeñas
Inyecte las dependencias

Comprobación rápida

Compruebe sus conocimientos sobre la filosofía de composición.

Repaso

Ha aprendido la filosofía de composición de Go.

No hay herencia; componga mediante embedding e interfaces
Modele tiene-un en lugar de es-un
Programe contra interfaces pequeñas e inyecte las dependencias
Acepte interfaces y devuelva structs

Preguntas frecuentes

¿La lección «Composición frente a herencia» es gratis?

Sí — el texto completo de «Composición frente a herencia» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Go Academy, actualiza a CoddyKit PRO. El curso de Go Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Composición frente a herencia»?

La filosofía de diseño de Go Practicas Go Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Go Academy?

No se requiere experiencia previa. Go Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.

¿Cuánto tiempo toma la lección «Composición frente a herencia»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Go Academy?

Sí. Cada lección de Go Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Go Academy