Composición

La composición es un concepto fundamental en la programación orientada a objetos (POO) que permite construir objetos complejos a partir de objetos más simples. A diferencia de la herencia, que se basa en la relación "es-un", la composición se basa en la relación "tiene-un".

¿Qué es la composición?

En esencia, la composición es una forma de reutilización de código que permite crear objetos que contienen otros objetos como partes. El objeto compuesto (el "todo") se construye a partir de objetos componentes (las "partes").

Características clave de la composición:

• Relación "tiene-un": Un objeto compuesto "tiene-un" objeto componente. Por ejemplo, un automóvil "tiene-un" motor.
• Acoplamiento fuerte: El objeto compuesto depende fuertemente de los objetos componentes. Si se elimina un objeto componente, el objeto compuesto también puede resultar afectado.
• Reutilización de código: La composición permite reutilizar objetos existentes para construir objetos más complejos.
• Flexibilidad: La composición ofrece mayor flexibilidad que la herencia, ya que permite cambiar o reemplazar los objetos componentes en tiempo de ejecución.

Ejemplos en diferentes lenguajes de programación:

A continuación, te presento ejemplos de composición en C++, C#, Python y Java:

C++:

C++

#include <iostream>

class Motor {
public:
    void arrancar() {
        std::cout << "Motor arrancando..." << std::endl;
    }
};

class Automovil {
private:
    Motor motor; // Composición: Automovil tiene-un Motor
public:
    void conducir() {
        motor.arrancar();
        std::cout << "Automovil en movimiento..." << std::endl;
    }
};

int main() {
    Automovil miAutomovil;
    miAutomovil.conducir();
    return 0;
}

C#:

C#

using System;

public class Motor {
    public void Arrancar() {
        Console.WriteLine("Motor arrancando...");
    }
}

public class Automovil {
    private Motor motor; // Composición: Automovil tiene-un Motor

    public Automovil() {
        motor = new Motor();
    }

    public void Conducir() {
        motor.Arrancar();
        Console.WriteLine("Automovil en movimiento...");
    }
}

public class EjemploComposicion {
    public static void Main(string[] args) {
        Automovil miAutomovil = new Automovil();
        miAutomovil.Conducir();
    }
}

Python:

Python

class Motor:
    def arrancar(self):
        print("Motor arrancando...")

class Automovil:
    def __init__(self):
        self.motor = Motor() # Composición: Automovil tiene-un Motor

    def conducir(self):
        self.motor.arrancar()
        print("Automovil en movimiento...")

mi_automovil = Automovil()
mi_automovil.conducir()

Java:

Java

public class Motor {
    public void arrancar() {
        System.out.println("Motor arrancando...");
    }
}

public class Automovil {
    private Motor motor; // Composición: Automovil tiene-un Motor

    public Automovil() {
        motor = new Motor();
    }

    public void conducir() {
        motor.arrancar();
        System.out.println("Automovil en movimiento...");
    }

    public static void main(String[] args) {
        Automovil miAutomovil = new Automovil();
        miAutomovil.conducir();
    }
}

En todos estos ejemplos, la clase Automovil contiene una instancia de la clase Motor, lo que demuestra la relación de composición.