Composición antes que herencia

  • Lección 3 de 32
  • 10 min
  • Inicial
  • 11 pasos

La herencia suele ser lo primero que aprendes de la programación orientada a objetos, y por eso se usa para todo. Aquí verás dónde se rompe y qué hacer en su lugar: armar objetos con piezas.

Clases con herencia
16
Piezas con composición
6
DuckDuck ·gomaDuckFlyingDuckFlyingDuckSwimmingDuckSwimmingDuckFlyingSwimmingDuckFlyingSwimmingDuckswimswimflyflyquackquackdivediveSkillinterfazSkillReaderabstractaReaderBufferedReaderBufferedReaderInputStreamReaderInputStreamReadertu programaWelcomeDialogWelcomeDialogDialogDialogFancyBorderFancyBorderHerenciaclass Duck { name = "duck"; }class FlyingDuck extends Duck {fly() { return "flies"; }}class SwimmingDuck extends Duck {swim() { return "swims"; }}es un Duck · vuelaes un Duck · nada2 × 2 × 2 = 8 clasesDuckFlyingDuckSwimmingDuck+QuackingDuckFlyingSwimmingDuck+FlyingQuackingDuck+SwimmingQuackingDuck+FlyingSwimmingQuackingDuckswim() copiado+4 clases con quackCambio en la clase baseclass Duck {+fly() { return "flies"; }}class SwimmingDuck extends Duck {}new SwimmingDuck().fly();// "flies": nadie lo pidió+ fly() en la base¡ahora vuela!Tiene un, no es uninterface Skill {use(): string;}class Duck {constructor(private skills: Skill[]) {}}interfaz: el contratoDuck tiene SkillsComposición+const fly = { use: () => "flies" };+const swim = { use: () => "swims" };+const quack = { use: () => "quacks" };class Duck {constructor(private skills: Skill[]) {}act() { return this.skills.map((s) => s.use()); }}delega en sus piezas3 implementacionesReact: composición de componentesfunction WelcomeDialog() {return (<Dialog title="Hola"message="Gracias por venir" />);}props: title, messagechildrenusa Dialog, no lo heredaCombinar al crearconst mallard =new Duck([fly, swim, quack]);+const rubber =+new Duck([swim, quack]);rubber.act(); // ["swims", "quacks"]pato de goma: nada y graznano se usaUna habilidad más+const dive: Skill = {+use: () => "dives" };+new Duck([swim, dive]);nueva piezaDuck no cambiaJava: java.ioBufferedReader in =new BufferedReader(new InputStreamReader(System.in));String line = in.readLine();es un Reader y tiene un Readerclase abstracta estableHerencia o composiciónHerenciamenos código al empezarfrágil si cambia la baseComposiciónpiezas intercambiablesmás objetos y cableadoHereda si…«es un» real y estableo el framework lo pidemás objetos que conectaruna interfaz mástiene piezasdepende de la interfaz
  • petición
  • respuesta

Paso 1 de 11

Problema

Heredar para reutilizar código

Tienes una clase Duck y quieres patos que vuelan y patos que nadan. Lo primero que se te ocurre: dos subclases, FlyingDuck y SwimmingDuck, que extienden Duck y le agregan un método.

Funciona y es poco código. Las flechas con triángulo hueco del diagrama significan «extiende»: cada subclase es un Duck. Ahora llega el primer pedido nuevo: un pato que vuela y nada.

Paso 2 de 11

Problema

Una clase por cada combinación

En TypeScript una clase solo puede extender una clase. FlyingSwimmingDuck hereda de FlyingDuck y tiene que copiar el código de nadar de SwimmingDuck.

Luego te piden patos que graznan. Con 3 habilidades que se combinan libremente hay 2 × 2 × 2 = 8 combinaciones, contando el Duck que no hace nada: 8 clases. Con una cuarta habilidad serían 16.

Qué cambió

  • FlyingSwimmingDuck, con swim() copiado
  • 4 clases más para graznar
  • Clases: de 3 a 8

Paso 3 de 11

Problema

La clase base frágil

Para no repetir código, alguien mueve fly() a Duck. Ahora todas las subclases lo heredan, incluida SwimmingDuck, que representa un pato de goma: new SwimmingDuck().fly() devuelve "flies".

Es el problema de la clase base frágil: un cambio razonable en la clase padre cambia el comportamiento de hijas que nadie tocó, y el compilador no avisa.

Qué cambió

  • fly() movido a Duck
  • SwimmingDuck hereda un fly() que no debía tener

Paso 4 de 11

Concepto

Tiene un, no es un

La alternativa es la composición: en lugar de que Duck sea varias cosas, Duck tiene piezas. Cada habilidad es un objeto aparte que cumple una interfaz Skill con un solo método, use().

Duck solo conoce la interfaz (el bloque con borde discontinuo), no cada habilidad concreta. El libro de patrones de Gamma, Helm, Johnson y Vlissides (1994) recomienda justamente esto: preferir la composición de objetos a la herencia de clases.

Qué cambió

  • Jerarquía de subclases
  • Interfaz Skill
  • Duck recibe sus Skills al crearse

Paso 5 de 11

Técnica

Duck delega en sus piezas

fly, swim y quack son objetos pequeños que implementan Skill (flecha discontinua con triángulo). Cuando le pides a Duck que actúe, recorre sus piezas y le delega el trabajo a cada una: son las peticiones y respuestas que ves en las líneas.

Las piezas que escribes son 5: Duck, Skill y 3 habilidades. Con herencia eran 8 clases, y cada habilidad nueva las duplica.

Qué cambió

  • fly, swim y quack implementan Skill
  • Piezas: 5 en lugar de 8 clases

Paso 6 de 11

Concepto

Caso real: los componentes de React

React aplica la misma idea a la interfaz de usuario. En su documentación (la versión antigua, legacy.reactjs.org) el ejemplo es un WelcomeDialog: en lugar de heredar de Dialog, lo usa y lo configura con props (title, message). Dialog, a su vez, envuelve su contenido en un FancyBorder usando children.

La misma página cuenta que en Facebook usaban React en miles de componentes y no habían encontrado ningún caso en el que recomendaran crear jerarquías de herencia de componentes.

Qué cambió

  • WelcomeDialog usa Dialog con props
  • Dialog envuelve sus children en FancyBorder

Paso 7 de 11

Solución

Cada pato, con las piezas que necesita

Volvamos a los patos. El pato de goma ya no necesita su propia clase: es un Duck creado con [swim, quack]. El pato real se crea con las tres piezas. La misma clase sirve para todas las combinaciones.

Y como las piezas son objetos, también puedes cambiarlas mientras el programa corre: un pato herido puede quedarse sin fly, algo que una subclase no puede hacer porque su tipo quedó fijo al escribirla.

Qué cambió

  • rubber = new Duck([swim, quack])
  • fly sin usar en este pato

Paso 8 de 11

Solución

Una habilidad nueva sin tocar Duck

Ahora te piden patos que bucean. Escribes una pieza nueva, dive, que implementa Skill. Duck no cambia ni una línea, y ningún pato existente cambia de comportamiento.

Con herencia, una cuarta habilidad lleva la cuenta a 2 × 2 × 2 × 2 = 16 clases. Con composición pasas de 5 piezas a 6: crece sumando, no multiplicando.

Qué cambió

  • Pieza dive
  • Herencia: 16 clases · composición: 6 piezas

Paso 9 de 11

Técnica

Caso real: herencia y composición juntas

En Java, BufferedReader extiende la clase abstracta Reader y además recibe otro Reader en su constructor, al que envuelve. La documentación de Java recomienda envolver con un BufferedReader cualquier Reader cuyas lecturas sean costosas, como FileReader o InputStreamReader.

Así no existe un BufferedFileReader, un BufferedStringReader… una sola clase agrega el búfer a cualquier fuente. La herencia aquí es poco profunda y estable (el contrato Reader); el comportamiento extra llega por composición.

Qué cambió

  • BufferedReader extiende Reader
  • BufferedReader envuelve un InputStreamReader

Paso 10 de 11

Compromiso

Cuándo la herencia sí conviene

La composición tiene costo: más objetos, una interfaz más y alguien que tiene que conectar las piezas al crear cada pato. Para un caso que nunca va a variar, puede ser ceremonia de más.

La herencia está bien cuando hay un «es un» real y estable con una jerarquía poco profunda, o cuando un framework te pide extender una clase base que él mismo llama (lo verás en Template Method). No la uses solo para reutilizar unos métodos.

Paso 11 de 11

Resumen

Resumen

Heredar para combinar comportamientos multiplica las clases y copia código.

Una clase base es frágil: sus cambios llegan a todas sus hijas.

Con composición, un objeto tiene piezas detrás de una interfaz y les delega el trabajo.

Las piezas se combinan al crear el objeto y se agregan sin tocar la clase.

Hereda para un «es un» real y estable; compón para combinar.

Aprenderás

  • Reconocer la explosión de subclases
  • Explicar el problema de la clase base frágil
  • Componer comportamiento con interfaces («tiene un»)
  • Combinar y agregar piezas sin tocar la clase
  • Elegir la herencia cuando de verdad conviene