Como se implementa la agregacion y composicion en php

[guarus]

Versión de PHP: 5
Pregunta: Como se implementa la agregacion y composicion en php

Saludos a la gente de la comunidad, me gustaria que alguien me diera un ejemplo de como implementar, tanto la agregacion y la composicion en php 5 por separado, y si es posible una explicacion del codigo, ya que buscado mucho en internet y no he podido conseguir nada al respecto.

Agradeceria su ayuda, gracias

[enriqueplace]

La diferencia entre agregación y composición es conceptual, no se diferencia por código.

Lo que es código se representa como la "agregación" de objetos por parte de un objeto único, por ejemplo: una clase Escuela "agrega" muchos Alumnos, lo que podría convertirse en un método "agregarAlumno" de la clase Escuela, donde lo único que hace es insertar el objeto dentro de una colección (array) de alumnos.

La composición se daría cuando la relación entre los dos tipos de objetos (Escuela, Alumno) es de "compuesto/componente" donde el componente no podría existir solo sin el compuesto.

Por ejemplo, en un contexto dado podría ser:

• Un círculo se dibuja como muchos puntos uno a continuación del otro, pero los puntos en nuestro contexto no pueden existir de forma aislada. Existe entonces una relación de composición entre Círculo y Puntos ("el círculo agrega muchos puntos").
• Una clase Banco que contiene muchos clientes y a su vez cada cliente contiene muchas cuentas. Se puede decir que hay una "relación de vida" entre Banco - Cliente y Cliente - Cuentas, donde los clientes no pueden estar "sueltos" en nuestro sistema sin estar asociados al Banco, de la misma forma no pueden existir Cuentas que no estén asociadas a un Cliente.

Me encontraste con ganas de escribir, pero te recuerdo que estos temas son elementales y se encuentra perfectamente la explicación conceptual de cada caso.

[guarus]

Muchas gracias por tu pronta respuesta Enrique Place, pero es algo confuso, por lo menos para mi que estoy comenzando con POO en php, y como dices, se consigue teoria en internet, mas no ejemplos que tambien queria ver, pero me distes una idea.
Gracias nuevamente, y si puedes darme un ejemplo con codigo de agregacion te lo agradeceria igualmente.

[enriqueplace]

Estimado: si te digo que es conceptual y no se diferencia por código... qué código quieres que te escriba?

Es tan simple como que en la clase Escuela crear un atributo colAlumnos (colección de alumnos, o el nombre que más te guste) que sea un array, luego, crear un método addAlumno donde recibes objetos de tipo Alumno y los agregas dentro del array con algo como:

Código PHP:

  class Escuela{ 
   private $colAlumnos; 
 
   public function addAlumno(Alumno $unAlumno){ 
      $this->colAlumnos[] = $unAlumno; 
   } 
}  
   

Si esto es agregación... ¿como es entonces una "composición"?

Cambia el contexto a uno en el que el componente no puede existir sin el compuesto, cambias los nombre, y el código es el mismo (Círculo y puntos).

Si quisiéramos ser puros con los diagramas UML que representan esta "semántica" (solo es eso, un problema de semántica que no tienen correlación con nuestros lenguajes de programación) deberíamos destruir al "objeto componente" (los puntos) una vez que se desasocian del "objeto compuesto" (el círculo) o algo por el estilo (existir un procedimiento que destruya el objeto que se detecte como desasociado a su "objeto compuesto").

En Java y en PHP no se puede hacer o directamente no tiene sentido hacer tal representación en código.

¿Tu dirás, para que existe el concepto y la representación en UML?

Bueno, para eso, para documentar una situación que no es necesariamente igual a la otra, que puede interesarte especificar en el desarrollo de tu sistema, tal vez, con un lenguaje que sí pueda representarlo, o que a ti te representa algo en tu proceso de desarrollo.

Pero te comento que hay una tendencia a reducir la complejidad de los diagramas UML y ser mucho más sencillos, evitando este tipo de representación y simplificando solo con "agregación".

[zsamer]

Me surgió una duda, con este buen topico:

Cuando tengo la siguiente situación podría ser considerada Composición?

Código PHP:

  <?php
class Alumnos{
   private $nombre = array();
   public function setNombre($nombre){
      $this->nombre[] = $nombre;
   }
   public function getNombre(){
      return $this->nombre;
   }
}

class Escuela{

   public function Alumnos(){
      return new Alumnos;
   }

}

$escuela = new Escuela;
$alumnos = $escuela->Alumnos();
$alumnos->setNombre('pepito');
$alumnos->setNombre('juanito');
$alumnos->setNombre('otro');

foreach ($alumnos->getNombre() as $a) {
    print "{$a}<br />\n";
}
?>   

[DarioDario]

Iniciado por zsamer

Me surgió una duda, con este buen topico:

Cuando tengo la siguiente situación podría ser considerada Composición?

Si yo no entiendo mal ésta no sería Composición... mas bien diría que tienen una relación de uso (que se representa con la linea puntuada).

Código:

Escuela    - - - - - - - - - - - - - - - >  Alumnos

Según lo que tengo entendido sobre Agregación es que la vida del objeto "Agregado" es independiente del "Agregador"... en cambio cuando es de Composición el tiempo de vida del primero muere con el segundo, se entiende?

Con código debería ser algo así (ejemplo sacados de esta pagina):

Agregación:

Código PHP:

  <?php 
class Dao { 
    function getSomething() { 
  
    } 
} 
  
class Model { 
    var $dao; 
    function Model (& $dao) { 
        $this->dao=& $dao; 
    } 
  
    function doSomething () { 
        $this->dao->getSomething(); 
    } 
} 
  
$dao=new Dao; 
  
$model=new Model($dao); 
$model->doSomething();   

Composición:

Código PHP:

  <?php 
class LinkWidget { 
  
} 
  
class View { 
    var $linkWidget; 
    var $page; 
    function View () { 
        $this->linkWidget=new LinkWidget; 
    } 
  
    function renderPage () { 
        $this->page=$this->linkWidget->display() 
    } 
} 
?>   

Saludos.

[enriqueplace]

En mi opinión diría que no tienes ninguna de las dos cosas y que el ejemplo tiene un problema de conceptos.

Algunos puntos:

• La clase Alumnos no tiene mucho sentido, lo que deberías crear como objeto sería un Alumno
• La Escuela debería contener los alumnos, por lo tanto debería ser un atributo de la misma el contenedor de Alumnos
• La clase Alumnos genera conceptualmente un "contenedor de Alumnos " el cual no guarda objetos sino nombres de alumnos... sueltos.
• ¿La clase Escuela solo tiene por función crear un objeto Alumnos? ¿Que sentido tendría? Debería ser algo interno de la clase Escuela contener los alumnos.

Si fueras un alumno novato te diría que estás entendiendo mal el uso de los objetos y que no les estás sacando provecho

[zsamer]

Gracias por las correcciones, estoy completamente de acuerdo, antes de publicar el tema pensé en escribir que "no tomaran en cuenta la lógica del ejemplo ya que no la tiene", bueno, pero no lo hice, no se me ocurrió otro ejemplo, lo hice para mostrar mi duda, a que concepto corresponde cuando una clase crea a otra y la retorna.

bueno quizás un ejemplo de mi duda anterior, que tenga sentido podría ser:

Código PHP:

  class Page {
    private $title;
    private $html;
    public function __construct($title='Default Page'){
        $this->title=$title;
        $this->html='';
    }
    public function makeHeader($header){
        $this->html.='<html><head><title>'.
         $this->title.'</title></head><body>'.$header;
    }
    public function makeBody($content=array()){
        return new Table($this,$content);
    }
    public function makeFooter($footer){
        $this->html.=$footer.'</body></html>';
    }
    public function display(){
        return $this->html;
    }
}


class Table {
    private $page;
    private $content;
    private $id;
    public function __construct(&$page,$content){
        $this->page=&$page;
        $this->content=$content;
        $this->id='defaultID';
    }
    public function setId($id){
        $this->id=$id;
    }
    public function build($colorA,$colorB){
        $this->page->html.='<table id="'.$this->id.'" width="100%">';
        $i=0;
        foreach($this->content as $row){
            $bgcolor=($i%2)?$colorA:$colorB;
            $this->page->html.='<tr bgcolor="'.$bgcolor.'">
             <td>'.$row.'</td></tr>';
            $i++;
        }
        $this->page->html.='</table>';
        return $this->page->html;
    }
}


$page=new Page();
$page->makeHeader('<div>Header</div>');

$table=$page->makeBody(range(0,20));
$table->setId('maincontent');
$table->build('#ffcc00','#eeeeee');

$page->makeFooter('<div>Footer</div>');
echo $page->display();  
   

Bueno espero comentarios si este ejemplo tiene algo o nada de composición.


PD: Aun sigo siendo novato, solo llevo algunos meses en oop.

[guarus]

Amigo enriqueplace, muchas gracias por responderme, en verdad solo queria ver parte de codigo para comprender mejor de la teoria, ya que soy novato en este tema y bueno la explicacion no me servia de mucho para comprender.
Gracias tambien a DarioDario y a zsamer por sus ejemplos, eso es lo que en verdad buscaba para comprender.
Saludos, seguire estando aqui para consultar otro duda

[DarioDario]

zsamer yo creo que no tiene nada de Composición. Según lo que entiendo la relación de Composición se resume en la siguiente frase:

Código:

El tiempo de vida del objeto incluido esta condicionado por el tiempo de vida del que lo incluye.

En el ejemplo que vos mostras si nos situamos antes del echo y destruimos la variable $page (que es una instancia de la clase Page) la variable $table no muere y directamente no "siente" nada. En teoría si muere el que incluye debería morir el incluido (En esta caso si muere Page, debería morir Table).

Ahora que me fijo mejor en el ejemplo que mostrar ni siquiera Page incluye a Table, lo único que hace es crearlo y devolverlo (no lo almacena) osea que en éste ejemplo la relación es de uso (linea punteada).

Hice el siguiente código a ver si se entiende lo que yo entiendo por Composición:

Código PHP:

  class Cuenta{ 
        private $numero = ''; 
 
        public function __construct($numero){ 
                $this->numero = $numero; 
        } 
 
        public function getNumero(){ return $this->numero; } 
} 
 
class Banco{ 
        private $nombre = ''; 
        private $direccion = ''; 
        private $cuentas = array(); 
 
        public function __construct($nombre,$direccion){ 
                $this->nombre = $nombre; 
                $this->direccion = $direccion; 
        } 
 
        public function agregarCuenta($numeroDeCuenta){ 
                $this->cuentas[] = new Cuenta($numeroDeCuenta); 
        } 
} 
 
$banco = new Banco('Nacion', 'Lejos de aca'); 
$banco->agregarCuenta(123); 
$banco->agregarCuenta(1234); 
$banco->agregarCuenta(12345);  
   

En este ejemplo si muere la instancia de Banco mueren todas las instancias de Cuenta que están almacenadas en Banco.

Saludos.

[zsamer]

Dario, comparto tu opinión y es lo que yo entendía sobre el "concepto de composición", hasta que me topé con este articulo Introduction to Composition, y despues de leerlo quedé con una gran duda sobre el "concepto de Composición", por eso es que aproveché este tópico para plantear y mostrar lo que presenta el articulo que leí sobre el tema.

Saludos.

[DarioDario]

Iniciado por zsamer

Dario, comparto tu opinión y es lo que yo entendía sobre el "concepto de composición", hasta que me topé con este articulo Introduction to Composition, y despues de leerlo quedé con una gran duda sobre el "concepto de Composición", por eso es que aproveché este tópico para plantear y mostrar lo que presenta el articulo que leí sobre el tema.

Saludos.

Osea que compartimos la misma opinión sobre la Composición?

Ahora leí el articulo (por arriba, me mareo con textos tan largos) y en la primera frase ya me encuentro con esto:

Código:

It occurs when an object creates another object; that is, the first object completely possesses the second object.

Traducido sería algo así (no me llevo muy bien con el ingles):

Código:

Esto ocurre (N.T: la Composición) cuando un objeto crea otro; es decir, el primer objeto posee completamente al segundo objeto.

Y con lo anterior terminamos en el mismo concepto... el objeto "principal" debe almacenar al otro objeto con lo cual, sí muere el primero muere el segundo.

Ahora yo creo que ese ejemplo no tiene ni pies ni cabeza con el tema de Composición, tal vez hay un algo conceptual que no entiendo en el articulo por lo que no lo entiendo... pero para mí no esta bien ese ejemplo. Y si lo pienso un poco no sería raro que este mal el articulo (obviamente lo tiene que leer alguien que sepa más que yo y que entienda bien el ingles y opine lo mismo que yo), cuanta mala información hay un internet? y cuando desactualizada? Entonces no sería muy raro que esto este mal.

De todas maneras espero que alguien con más experiencia opine, pero mi conclusión es la que dije

Saludos.

[DarioDario]

He publicado un post en mi blog sobre este tema, si a alguien le interesa aquí esta mi blog.

Saludos.

[guarus]

Hola nuevamente, continuando con la agregacion, tengo lo siguiente:

Una clase llamada Proyecto que contiene 2 atributos:$idproyecto y $descripcion y sus respectivos gets y sets unicamente. Seguidamente tengo otra clase llamada JefeProyecto que contiene 2 atributos igualmente: $idjefeproyecto y el otro $proyectos que es donde deseo guardar los objetos de la clase proyecto, en esta clase tengo el get y set de $idjefeproyecto y tengo una funcion llamada agregarproyecto con lo siguinte

public function agregarproyectos($unproyecto)
{
$this->proyectos[] = $unproyecto;
}

Mi pregunta es ¿Una vez que creo el objeto $jp, que es de tipo JefeProyecto, y creo tambien 3 objetos de tipo Proyecto y les agrego a cada uno de estos sus id y descripcion, los agrego al atributo $proyectos de $jp atraves de la funcion anteiormente mostrada. Hecho esto, Como hago para acceder a cada uno de estos objetos, desde $jp, y mostrar sus respectivos datos?

Me gustaria que me explicaran mediante codigo, con los datos que les describe anteriormente. Gracias

Lo tengo de esta forma y me da error


$jp = new JefeProyecto();
$p = new Proyecto();

$p->setID('01');
$p->setDescripcion('POO');

$jp->setIDProyecto('01');
$jp->agregarproyectos(p);

echo $jp->proyectos->getDescripcion() //error en el acceso

[GatorV]

Tendrias que implementar alguna funcion que te regrese el index de un proyecto, o en su caso todos los proyectos y hacer un loop:

Código PHP:

  echo $jp->getProyecto(1)->getDescripcion();  
   

[guarus]

gracias GatorV por tu respuesta, pero si podrias decirme con codigo lo que me explicastes te lo agradeceria, lo que pasa es que soy novato en este tema y no entiendo bien.

[GatorV]

Código PHP:

  class JefeProyecto {
     private $proyectos = array();

     public funcion getProyecto($index) {
           return $proyectos[$index];
     }
}  
   

Obvio necesitas hacer chequeos para que no sea un index fuera de la lista o no numerico, etc.

[enriqueplace]

Bueno, no voy a citar nada de lo expuesto porque quiero empezar de cero... además, casi que no te tomaste el tiempo para hacer una exposición simple y clara de tu duda, lo cual casi me da la misma pereza para leerte.

Vamos a los conceptos, el código -estimado haragán- se saca razonando (lo único que espero y rezo a todos los demonios es que no nos estés pasando tareas de estudio a los colegas de la lista).

Aquí, como siempre se repite en esta lista, el problema no es de código, es de conceptos y de ser obstinados en no razonar y esperar que te den la comida regurgitada.

¿Sabes por qué te lo digo? El método "prueba y error" es sinónimo de desorden, falta de metodología, de razonamiento, lo cual cada cosa que intentes te llevará mucho más tiempo que si te sientas a razonarlo por un buen rato.

Por ejemplo, me imagino que todos los "id" que colocas por todos lados los debes usar porque necesitas una correspondencia con un modelo "relacional" (bases de datos) y no porque son necesarios para trabajar con objetos. Ahora bien, razonando, no veo en ningún momento que hables de bases de datos, por lo tanto para simplificar el ejemplo y concentrarnos en los conceptos de la POO debes eliminar los "id".

Código PHP:

  <?php 
 
class Proyecto{ 
   private $descripcion; 
   public function __construct( $descripcion ){ 
      $this->descripcion = $descripcion; 
   } 
   public function getDescripcion(){ return $this->descripcion; } 
} 
 
class JefeProyecto{ 
    private $nombre; 
       private $colProyectos = array(); 
       public function __construct( $nombre ){ 
           $this->nombre = $nombre; 
       } 
       public function addProyecto( Proyecto $proyecto ){ 
           $this->colProyectos[] = $proyecto; 
       } 
       public function listarProyectos(){ 
           foreach( $this->colProyectos as $proyecto ){ 
               $retorno .= $proyecto->getDescripcion() . " "; 
           } 
           return $retorno; 
       } 
} 
 
$jefe = new JefeProyecto( "Enrique" ); 
 
$jefe->addProyecto( new Proyecto("POO") ); 
$jefe->addProyecto( new Proyecto("Estructurado") ); 
 
echo $jefe->listarProyectos(); 
 
//var_dump( $jefe ); // Si quieres ver como está compuesto internamente 
 
?>   

Entiende el concepto: los objetos están compuestos por otros objetos, unos contienen a otros. Eso es agregación. Punto, no le des más vueltas.

PD: espero que no pierdas el tiempo en ofenderte por mi forma de expresarme, espero que valores la cruda y dura sinceridad de mi despiadado ser (y lo de "colaborador" es solo un error de sintaxis).

[B**]

Iniciado por enriqueplace

Entiende el concepto: los objetos están compuestos por otros objetos, unos contienen a otros. Eso es agregación. Punto, no le des más vueltas.

Composicion.

[enriqueplace]

Agregación, que es el caso más genérico y válido, la composición es un caso particular de agregación que generalmente no se implementa, por consiguiente muchos autores simplifican y siempre dicen "agregación".

[hectorjazz]

gracias a todos por sus aclaraciones, el agregador significa agregar un objeto en otro objeto, asi de simple, incluso podria tomarse por agregacion :

<?php
class DatosGenerales{
var $direccion;
var $otro_dato:
}

class MiClase{
var $collection[];
public funcion__construct(){
$this->collection[]= new DatosGenerales();
}
}

y de ahi para abajo todo lo que quieran.

Saludos

[enriqueplace]

Noup, eso es dependencia. Ahí literalmente no agregas nada.

Lo básico en las relaciones entre objetos es:

Dependencia: cuando recibes un objeto por parámetro o cuando creas una instancia de otro objeto dentro de un método (en UML es una flecha de línea punteada). También se le dice "relación de uso" porque lo que estás haciendo es "usar" a otro objeto.

Asociación: cuando la relación es "estructural", es decir, el objeto es parte de la estructura propia de la construcción del objeto. Por ejemplo, tu objeto está compuesto por atributos que son a su vez otros objetos (en UML es una flecha de línea continua). Esta relación es "más fuerte" que la anterior.

Agregación: tú -literalmente- agregas objetos a tu objeto a través de un método y lo colocas en una estructura contenedora de objetos, como son los arrays (en UML es una flecha continua pero con un rombo en una de sus extremos). La composición es un caso particular de agregación (en UML es lo mismo pero el rombo pintado en negro) y generalmente se dice que solo aporta "semántica" pero que en la vida real es raro que se implemente (por la existencia de garbage collector en Java o como en PHP que todo desaparece cuando termina la ejecución de una página).

¿Queda más claro ahora con este resumen?

Mmm... no es más productivo leer un libro como "UML Gota a Gota" que explica todos los conceptos? Estudiar POO sin UML es una pérdida de tiempo, puesto que cuando te aprendes UML aprendes conceptos. Y eso es lo que te falta.

[hectorjazz]

Gracias, ahora me quedo mas claro.

Saludos.