Conceptos básicos de la POO

Me ha parecido interesante hacer un pequeño resumen de las distintas relaciones que podemos encontrar en la Programación Orientada a Objetos (POO) y su implementación en PHP. Seguro que muchos encontréis interesante este mini resumen del tema y los ejemplos que pongo.

Vamos a verlos gráficamente mediante su representación en UML y a continuación los describimos brevemente para después entender bien el código.



Estos son básicamente los tipos de relaciones que nos podemos encontrar aunque existen algunas más. Vamos a verlos:

Composición
Es una relación estructural donde los objetos relacionados tan sólo tienen sentido conjuntamente. El contenedor debe crearlos y contener un método que destruya los objetos que lo componen cuando este sea borrado, ya que estos carecen de sentido sin él.

class Ala {
    // Atributos y metodos
}

class Avion {

    private $alaIzquierda;
    private $alaDerecha;

    public function __construct() {
        $this->alaIzquierda = new Ala();
        $this->alaDerecha = new Ala();
    }

    function __destruct() {
        unset($this->alaDerecha);
        unset($this->alaIzquierda);
    }
}

$boing = new Avion();

Agregación
Es una relación estructural donde el contenedor mantiene un array o collection, etc. con los objetos que pertenecen a esta asociación. Debe contener a su vez un método para agregar nuevos objetos. En este caso la destrucción del contenedor no implica que los objetos agregados deban ser destruidos.

class Aeropuerto {
    // Atributos y metodos
}

class Ciudad {

    private $aeropuertos = array();

    function addAeropuerto( Aeropuerto $aeropuerto ) {
        array_push( $this->aeropuertos, $aeropuerto );
    }
}

$amsterdam = new Ciudad();
$amsterdam->addAeropuerto('Schipol');

Asociación
Relación estructural entre clases, en donde en ambas existe un atributo que referencia al otro. El tipo de atributo, si es sólo una instancia o un array, define la cardinalidad.

class Revista {
    private $personas = array();
}

class Persona {
    private $revistas = array();
}

$manu = new Persona();
$pcactual = new Revista();

Dependencia
Se trata de una relación de uso. Un clase utiliza a otra. Es por ejemplo si creamos un nuevo objeto con el operador "new" dentro de otra clase.

class Matematicas{
    function potencia(){
    }
    function raizCuadrada(){
    }
}
class Ecuacion{
    private $mates;
    
    function __construct(){
        $this->mates = new Matematicas();
    }
    
    function resuelve(){
    }
}

Herencia
Relación estructural donde una subclase hereda los atributos y los métodos de una Super Clase. Aunque las subclases pueden implementar sus propios métodos y clases. En los casos donde la superClase no tenga sentido por si sola esta se suele definirse abstracta. Luego lo vemos.

class Vehiculo
{
    private $ruedas;
    private $potencia;

    function avanza(){
 // Codigo
    }

    function gira(){
 // Codigo
    }
}

class Moto extends Vehiculo
{
    private $sidecar;

    function avanza(){
 // Overridden
    }
}

$yamaha = new Moto();