Lección 17 de 36 · Interfaces, composición y genéricos✦ WebMCP implementado
Composición con embedding: sin extends ni traits
8 min de lectura3 retos
Go no tiene extends ni trait. Para reutilizar código mete un struct dentro de otro (embedding) y sus campos y métodos «suben» al de fuera. Parece herencia, pero no lo es, y esa diferencia es la que más sorprende a quien viene de PHP.
En 4 ideas
1/4
Embeber es poner un tipo dentro de un struct sin nombre de campo: type TareaUrgente struct { Tarea }. En PHP sería class TareaUrgente extends Tarea o un use ConMarcaDeTiempo;.
Los campos y métodos del tipo de dentro se promocionan: u.Titulo y u.Describir() funcionan sin escribir u.Tarea.. Como lo heredado en PHP.
No es herencia: un método de Tarea que llama a otro método llama siempre al de Tarea, nunca a la versión de TareaUrgente. En PHP, $this->etiqueta() llamaría a la del hijo.
También se embeben interfaces: RepositorioTareas puede ser Lector + Escritor, como interface A extends B, C en PHP, y un struct puede embeber una interfaz para decorarla.
1 · Sin extends ni traits: embedding
Herencia es decir «una TareaUrgentees una Tarea». Composición es decir «una TareaUrgentelleva dentro una Tarea». Piensa en una mochila: no es un estuche, pero lleva uno dentro y puedes sacar los lápices sin abrir el estuche a mano.
En Go se escribe el tipo dentro del struct sin nombre de campo. A eso se le llama embedding (incrustar):
package main
import"fmt"// En PHP: trait ConMarcaDeTiempotypeMarcaDeTiempostruct {
CreadaEnstring
}
func (m MarcaDeTiempo) Antiguedad() string {
return"creada el " + m.CreadaEn
}
typeTareastruct {
Titulostring
}
func (t Tarea) Describir() string {
return"Tarea: " + t.Titulo
}
// TareaUrgente LLEVA DENTRO una Tarea y una MarcaDeTiempo (sin nombre de campo).// En PHP: class TareaUrgente extends Tarea { use ConMarcaDeTiempo; }typeTareaUrgentestruct {
TareaMarcaDeTiempo
}
// Tapa el Describir de Tarea y lo reutiliza.func (u TareaUrgente) Describir() string {
// En PHP: parent::describir()return"¡URGENTE! " + u.Tarea.Describir()
}
funcmain() {
u := TareaUrgente{
Tarea: Tarea{Titulo: "Pagar el alquiler"},
MarcaDeTiempo: MarcaDeTiempo{CreadaEn: "2026-11-17"},
}
fmt.Println(u.Describir())
// Antiguedad() «sube» desde MarcaDeTiempo
fmt.Println(u.Antiguedad())
// Los campos también suben: u.Titulo es u.Tarea.Titulo
fmt.Println(u.Titulo)
}
Fíjate en dos cosas. El campo embebido se llama como su tipo: u.Tarea y u.MarcaDeTiempo. Y el parent::describir() de PHP es simplemente u.Tarea.Describir(): llamas al método del campo de dentro por su nombre.
Equivalencia POO · PHP → Go
Todo lo que en PHP haces con herencia y traits, en Go se hace metiendo structs dentro de structs (y con interfaces cuando necesitas polimorfismo).
PHP
Go
Quién lo ve
class TareaUrgente extends Tarea
type TareaUrgente struct { Tarea }
Los campos y métodos públicos de Tarea suben a TareaUrgente
use ConMarcaDeTiempo; (trait)
struct { MarcaDeTiempo }
Igual: lo de MarcaDeTiempo sube al struct de fuera
parent::describir()
u.Tarea.Describir()
Cualquiera: el campo embebido es un campo más
protected
No existe
Lo que empieza por minúscula lo ve todo el paquete
abstract class / final class
No existen: no hay herencia que limitar
Para «obligar a implementar», una interfaz
interface A extends B, C
type A interface { B; C }
Quien use A necesita todos los métodos de B y C
2 · Promoción de campos y métodos
Cuando escribes u.Titulo, Go busca Titulo primero en TareaUrgente. Si no lo encuentra, baja un nivel y lo busca en los tipos embebidos. A eso se le llama promoción: lo de dentro sube.
Si el de fuera tiene un campo o método con el mismo nombre, gana el de fuera y tapa al de dentro (como un método que sobrescribes).
Al de dentro siempre puedes llegar por su nombre completo: u.Tarea.Describir().
Si dos tipos embebidos al mismo nivel tienen el mismo nombre y el de fuera no lo tapa, Go no elige por ti.
Ese último caso es el problema del diamante de la herencia múltiple. PHP lo resuelve con insteadof en los traits; Go se niega a compilar si lo usas:
Gomain.go
typeAuditoriastruct{ Autorstring }
func (a Auditoria) Resumen() string { return a.Autor }
typeEtiquetadostruct{ Etiquetastring }
func (e Etiquetado) Resumen() string { return e.Etiqueta }
typeTareaAuditadastruct {
AuditoriaEtiquetado
}
// t.Resumen(): ¿el de Auditoria o el de Etiquetado?
ambiguous selector t.Resumen
Gomain.go
package main
import"fmt"typeContadorstruct {
total int
}
// Receptor puntero: cambia el contador de verdad.func (c *Contador) Sumar() {
c.total++
}
func (c Contador) Total() int {
return c.total
}
typeListastruct {
NombrestringContadorTareas []string
}
func (l *Lista) Agregar(titulo string) {
l.Tareas = append(l.Tareas, titulo)
// Sumar() sube desde Contador. En PHP: $this->sumar() de un trait.
l.Sumar()
}
funcmain() {
hoy := &Lista{Nombre: "Hoy"}
hoy.Agregar("Comprar pan")
hoy.Agregar("Repasar Go")
fmt.Println(hoy.Nombre, "tiene", hoy.Total(), "tareas:", hoy.Tareas)
}
3 · No es herencia: el método del de dentro no ve al de fuera
Aquí está la trampa. En PHP, cuando un método de la clase padre llama a $this->etiqueta(), PHP mira qué objeto es de verdad y llama a la versión del hijo. Go no hace eso.
Cuando Tarea.Describir() llama a t.Etiqueta(), t es una Tarea, punto. La Tarea no sabe que vive dentro de una TareaUrgente, igual que el estuche no sabe en qué mochila está:
Gomain.go
package main
import"fmt"typeTareastruct {
Titulostring
}
func (t Tarea) Etiqueta() string {
return"normal"
}
// Describir llama a t.Etiqueta(): t es SIEMPRE una Tarea.func (t Tarea) Describir() string {
return"[" + t.Etiqueta() + "] " + t.Titulo
}
typeTareaUrgentestruct {
Tarea
}
// Tapa Etiqueta... pero solo para quien llame a u.Etiqueta().func (u TareaUrgente) Etiqueta() string {
return"URGENTE"
}
funcmain() {
u := TareaUrgente{Tarea{Titulo: "Pagar el alquiler"}}
fmt.Println(u.Etiqueta())
// En PHP saldría [URGENTE]; en Go sale [normal].
fmt.Println(u.Describir())
}
Y otra diferencia: una TareaUrgenteno es una Tarea. No puedes pasarla a una función que pide Tarea; tienes que pasar u.Tarea:
Gomain.go
funcImprimir(t Tarea) { fmt.Println(t.Titulo) }
u := TareaUrgente{Tarea{Titulo: "Pagar"}}
// No compila: TareaUrgente no es TareaImprimir(u)
// Compila: le pasas la Tarea que lleva dentroImprimir(u.Tarea)
cannot use u (variable of struct type TareaUrgente) as Tarea value in argument to Imprimir
¿Por qué? · En PHP no existe
¿Por qué Go no tiene herencia? En PHP es lo normal
La herencia ata al hijo con el padre por dentro. Si cambias un método del padre, puedes romper hijos que ni conoces, porque PHP llama a sus versiones sin avisar. Es el problema de la clase base frágil, y la razón de que en PHP moderno se recomiende marcar las clases como final.
En Go cada tipo hace solo lo suyo. Lo que el de fuera reutiliza está a la vista (u.Tarea) y nadie cambia el comportamiento del de dentro por la espalda. Cuando de verdad quieres que algo varíe, lo dices con una interfaz:
Gomain.go
typeEtiquetadorinterface {
Etiqueta() string
}
// El que varía (la etiqueta) entra por parámetro, a la vista.funcDescribir(e Etiquetador, titulo string) string {
return"[" + e.Etiqueta() + "] " + titulo
}
Así se evita el extends de cinco niveles en el que nadie sabe ya qué método se ejecuta.
4 · Embeber interfaces: contratos que se suman y decoradores
Una interfaz puede llevar otras dentro. Es tu interface RepositorioTareas extends Lector, Escritor de PHP. La biblioteca estándar lo hace mucho: io.ReadWriter es io.Reader + io.Writer.
Así, una función que solo lee pide LectorTareas y no puede borrar nada por error.
Y un struct puede embeber una interfaz. Todos sus métodos suben, y tú tapas solo los que quieres cambiar. Es el patrón decorador: envolver algo para añadirle un extra (un log, una caché) sin tocarlo, como poner una funda al móvil.
Haz que TareaAuditada embeba también Auditoria, y cambia la segunda línea de main para que use el método promocionado u.Firma(). Debe imprimir Tarea: Comprar pan y firmada por Ana. Es el use UnTrait; de PHP.
Al pulsar Comprobar, unos tests ocultos prueban tu código con el compilador oficial de Go.
Gomain.go · editable
Pista. Añade la línea Auditoria (sin nombre de campo) dentro de TareaAuditada y rellénala al crear u: Auditoria: Auditoria{Autor: "Ana"}.
Reto 2 de 3 · ✓ Resuelto
La lista que cuenta
Lista embebe un Contador. Haz que Agregar(t Tarea) añada la tarea a l.Tareasy sume uno al contador usando el método promocionado Sumar(), para que l.Total() diga cuántas se han agregado. En PHP sería llamar a $this->sumar() que viene de un trait.
Al pulsar Comprobar, unos tests ocultos prueban tu código con el compilador oficial de Go.
Gomain.go · editable
Pista. Dos líneas: l.Tareas = append(l.Tareas, t) y l.Sumar(). Sumar sube desde Contador, no hace falta escribir l.Contador.Sumar().
Reto 3 de 3 · ✓ Resuelto
Un decorador que cuenta
RepoContador embebe un RepositorioTareas. Tapa solo Guardar(t Tarea) (Tarea, error) para que sume uno a Guardados y delegue en el repositorio de dentro (si no, la tarea no se guarda). Listar y BuscarPorID deben subir solos, sin escribirlos. Es el patrón decorador de PHP, pero sin reescribir los métodos que solo delegan.
Al pulsar Comprobar, unos tests ocultos prueban tu código con el compilador oficial de Go.
Gomain.go · editable
Pista. Primero r.Guardados++. Después llama al Guardar del de dentro por su nombre completo: return r.RepositorioTareas.Guardar(t). Si escribes r.Guardar(t), se llama a sí mismo sin fin.
Resumen
Lo que te llevas de esta lección
Embeber es poner un tipo sin nombre de campo: struct { Tarea } (en PHP, extends Tarea o use UnTrait;).
Los campos y métodos de dentro suben: u.Titulo, u.Describir(); y el de fuera puede taparlos (como sobrescribir).
parent::metodo() es u.Tarea.Metodo(): el campo embebido se llama como su tipo.
No es herencia: el de dentro no llama a los métodos del de fuera, y una TareaUrgente no es una Tarea (en PHP, $this sí ve al hijo).
Las interfaces se suman embebiéndolas (interface A extends B, C) y un struct que embebe una interfaz es un decorador gratis.
Para recordarlo: «Lleva dentro, no es»
Como la mochila y el estuche: la mochila lleva dentro un estuche y puedes sacar los lápices directamente, pero la mochila no es un estuche, y el estuche no sabe en qué mochila está.