Enlazador (patrón de diseño)
La versión actual de la página aún no ha sido revisada por colaboradores experimentados y puede diferir significativamente de la
versión revisada el 9 de mayo de 2016; las comprobaciones requieren
16 ediciones .
El patrón compuesto es un patrón de diseño estructural que combina objetos en una estructura de árbol para representar una jerarquía desde lo particular hasta el todo. El enlazador permite a los clientes acceder a objetos individuales y grupos de objetos de la misma manera.
Propósito
El patrón define una jerarquía de clases que pueden consistir simultáneamente en objetos primitivos y complejos, simplifica la arquitectura del cliente y facilita el proceso de agregar nuevos tipos de objetos.
Descripción
Plantilla de diagrama
UML :
Ejemplos de implementación
Ejemplo de Java
Fuente Java
importar java.util.List ;
importar java.util.ArrayList ;
/** "Componente" */
interfaz gráfica {
// Imprime el gráfico.
impresión de vacío público ();
}
/** "Compuesto" */
class CompositeGraphic implementa Gráfico {
//Colección de gráficos secundarios.
Lista privada < Gráfico > mChildGraphics = new ArrayList < Gráfico > ();
// Imprime el gráfico.
public void print () {
para ( gráfico gráfico : mChildGraphics ) {
gráfico . imprimir ();
}
}
//Añade el gráfico a la composición.
public void add ( Gráfico gráfico ) {
mChildGraphics . añadir ( gráfico );
}
//Elimina el gráfico de la composición.
public void remove ( Gráfico gráfico ) {
mChildGraphics . eliminar ( gráfico );
}
}
/** "Hoja" */
clase Ellipse implementa Gráfico {
// Imprime el gráfico.
public void imprimir () {
System . fuera _ println ( "Elipse" );
}
}
/** Cliente */
programa de clase pública {
public static void main ( String [] args ) {
// Inicializar cuatro puntos suspensivos
Ellipse ellipse1 = new Ellipse ();
Elipse elipse2 = nueva Elipse ();
Elipse ellipse3 = nueva Elipse ();
Elipse ellipse4 = nueva Elipse ();
//Inicializar tres gráficos
compuestos CompositeGraphic graphic = new CompositeGraphic ();
CompositeGraphic graphic1 = new CompositeGraphic ();
CompositeGraphic graphic2 = new CompositeGraphic ();
//Compone los gráficos
graphic1 . agregar ( elipse1 );
gráfico1 . agregar ( elipse2 );
gráfico1 . añadir ( elipse3 );
gráfico2 . añadir ( elipse4 );
gráfico _ añadir ( gráfico1 );
gráfico _ añadir ( gráfico2 );
//Imprime el gráfico completo (cuatro veces la cadena "Elipse").
gráfico _ imprimir ();
}
}
Ejemplo en C#
Texto fuente en C#
class MainApp
{
static void Main ()
{
// Crear una estructura de árbol
Compuesto raíz = nuevo Compuesto ( "raíz" );
raíz _ Añadir ( nueva Hoja ( "Hoja A" ));
raíz _ Añadir ( nueva Hoja ( "Hoja B" ));
Composite comp = new Composite ( "CompositeX" );
borrador _ Agregar ( nueva Hoja ( "Hoja XA" ));
borrador _ Agregar ( nueva Hoja ( "HojaXB" ));
raíz _ Añadir ( comp );
raíz _ Añadir ( nueva Hoja ( "Hoja C" ));
// Agregar y eliminar una hoja
Leaf leaf = new Leaf ( "Hoja D" );
raíz _ Añadir ( hoja );
raíz _ Quitar ( hoja );
// Muestra recursivamente la
raíz del árbol . pantalla ( 1 );
// Esperar a la
Consola del usuario . leer ();
}
}
/// <summary>
/// Componente - componente
/// </summary>
/// <li>
/// <lu>declara una interfaz para objetos componibles;</lu>
/// <lu>proporciona una operaciones predeterminadas de implementación adecuadas,
/// comunes a todas las clases;</lu>
/// <lu>declara una interfaz para acceder y manipular elementos secundarios;</lu>
/// <lu>define una interfaz para acceder al elemento principal del componente en una estructura recursiva
/// y opcionalmente la implementa. Esta función es opcional;</lu>
/// </li>
clase abstracta Componente { protected string name ;
// Constructor
public Component ( nombre de cadena ) { this . nombre = nombre ; }
Visualización de vacío abstracto público ( profundidad int ); }
/// <summary>
/// Composite: un objeto compuesto
/// </summary>
/// <li>
/// <lu>define el comportamiento de los componentes que tienen hijos;</lu>
/// < lu >almacena los componentes secundarios;</lu>
/// <lu>implementa operaciones relacionadas con la gestión secundaria y la interfaz /// de la
clase <see cref="Component"/></lu>
/// </li>
Compuesto : Componente { lista privada < Componente > niños = nueva Lista < Componente >();
// Constructor
public Composite ( string name ) : base ( name )
{
}
public void Añadir ( componente componente )
{
niños . Agregar ( componente );
}
public void Quitar ( componente componente )
{
niños . Quitar ( componente );
}
public override void Mostrar ( profundidad int ) { Consola . WriteLine ( nueva cadena ( '-' , profundidad ) + nombre );
// Mostrar de forma recursiva los nodos secundarios
foreach ( componente componente en hijos )
{
componente . Pantalla ( profundidad + 2 );
}
}
}
/// <summary>
/// Leaf - leaf
/// </summary>
/// <remarks>
/// <li>
/// <lu>representa el nodo hoja de la composición y no tiene hijos;< /lu>
/// <lu>define el comportamiento de los objetos primitivos en la composición;</lu>
/// </li>
/// </remarks>
class Leaf : Component
{
// Constructor
public Leaf ( string name ) : base ( nombre )
{
}
public override void Mostrar ( profundidad int ) { Consola . WriteLine ( nueva cadena ( '-' , profundidad ) + nombre ); } }
Ejemplo de C++
Texto fuente en C++
#incluir <iostream>
#incluir <lista>
#incluye <algoritmo>
#include <memoria>
clase ITexto {
público :
typedef std :: shared_ptr < IText > SPtr ;
sorteo de vacío virtual () = 0 ;
añadir vacío virtual ( const SPtr & ) {
throw std :: runtime_error ( "IText: No se puede agregar a una hoja" );
}
eliminación de vacío virtual ( const SPtr & ){
throw std :: runtime_error ( "IText: No se puede eliminar de una hoja" );
}
};
clase TextoCompuesto : public IText {
público :
anular agregar ( const SPtr & sptr ){
niños_ . push_back ( sptr );
}
anular eliminar ( const SPtr & sptr ){
niños_ . eliminar ( sptr );
}
void replace ( const SPtr & oldValue , const SPtr & newValue ){
std :: replace ( children_ . begin (), children_ . end (), oldValue , newValue );
}
sorteo de vacío virtual (){
para ( SPtr & sptr : niños_ ){
sptr -> dibujar ();
}
}
privado :
std :: lista < SPtr > niños_ ;
};
carta de clase : public IText {
público :
Letra ( char c ) : c_ ( c ) {}
sorteo de vacío virtual (){
std :: cout << c_ ;
}
privado :
char c_ ;
};
int principal (){
oración de texto compuesto ;
IText :: SPtr lSpace ( nueva letra ( ' ' ));
IText :: SPtr lExcl ( nueva letra ( '!' ));
IText :: SPtr lComma ( nueva letra ( ',' ));
IText :: SPtr lNewLine ( nueva letra ( '\n' ));
IText :: SPtr lH ( nueva letra ( ' H' )); // letra 'H' IText :: SPtr le ( nueva Letra ( 'e' )); // letra 'e' IText :: SPtr ll ( nueva Letra ( 'l' )); // letra 'l' IText :: SPtr lo ( nueva Letra ( 'o' )); // letra 'o' IText :: SPtr lW ( nueva letra ( ' W' )); // letra 'W' IText :: SPtr lr ( nueva Letra ( 'r' )); // letra 'r' IText :: SPtr ld ( nueva Letra ( 'd' )); // letra 'd' IText :: SPtr li ( nueva Letra ( 'i' )); // letra i'
IText :: SPtr wHello ( nuevo texto compuesto );
wHola -> agregar ( lH );
wHola -> agregar ( archivo );
wHola -> agregar ( ll );
wHola -> agregar ( ll );
wHola -> agregar ( lo );
IText :: SPtr wWorld ( nuevo texto compuesto ); // palabra "Mundo" wMundo -> add ( lW );
wMundo -> añadir ( lo );
wMundo -> añadir ( lr );
wMundo -> agregar ( ll );
wMundo -> agregar ( ld );
frase _ add ( wHola );
frase _ agregar ( lComma );
frase _ agregar ( lEspacio );
frase _ agregar ( wMundo );
frase _ agregar ( lExcl );
frase _ agregar ( lNuevaLínea );
frase _ dibujar (); // imprime "¡Hola, mundo!\n"
IText :: SPtr wHi ( nuevo texto compuesto ); // palabra "Hola" wHi -> agregar ( lH );
whi -> añadir ( li );
frase _ reemplazar ( wHola , wHi );
frase _ dibujar (); // imprime "¡Hola, mundo!\n"
frase _ quitar ( wMundo );
frase _ eliminar ( lEspacio );
frase _ quitar ( lComa );
frase _ dibujar (); // imprime "¡Hola!\n"
devolver 0 ;
}
Ejemplo en D
Texto de origen en lenguaje D
estándar de importación estudio _
clase abstracta TInfo
{
protegido :
cadena nombre ;
público :
información vacía (); }
clase TFile : TInfo
{
protegido :
uint tamaño ;
public :
this ( const string elNombre , uint elTamaño )
{
nombre = elNombre ;
tamaño = elTamaño ;
}
void Info ()
{
writefln ( "%s\t%d" , nombre , tamaño );
}
}
clase TDir : TInfo
{
protegido :
TInfo [] info ;
public :
this ( const string elNombre )
{
nombre = elNombre ;
}
void Info ()
{
writefln ( "[%s]" , nombre );
foreach ( f ; información )
{
f . información ();
}
}
void Agregar ( TInfo theInfo )
{
info ~= theInfo ;
}
}
void principal ()
{
TDir primero = nuevo TDir ( "primero" );
primero _ Agregar ( nuevo TFile ( "a.txt" , 100 ));
primero _ Agregar ( nuevo TFile ( "b.txt" , 200 ));
primero _ Agregar ( nuevo TFile ( "c.txt" , 300 ));
TDir segundo = new TDir ( "segundo" );
segundo _ Agregar ( nuevo TFile ( "d.txt" , 400 ));
segundo _ Agregar ( nuevo TFile ( "e.txt" , 500 ));
TDir raíz = new TDir ( "raíz" );
raíz _ Añadir ( primero );
raíz _ Añadir ( segundo );
raíz _ información ();
}
Ejemplo de Python
Código fuente en Python
de abc import ABCMeta , método abstracto
class Unit ( metaclass = ABCMeta ):
"""
Un componente abstracto, en este caso es una unidad (una unidad puede
constar de uno o más soldados)
"""
@abstractmethod
def print ( self ) -> Ninguno :
"""
Imprimir datos del componente
"""
pasar
clase Arquero ( Unidad ):
"""
Arquero
"""
def print ( self ) -> Ninguno :
print ( 'arquero' , end = ' ' )
clase Caballero ( Unidad ):
"""
Caballero
"""
def imprimir ( auto ) -> Ninguno :
imprimir ( 'caballero' , final = ' ' )
clase Espadachín ( Unidad ):
"""
Espadachín
"""
def print ( self ) -> Ninguno :
print ( 'espadachín' , end = ' ' )
clase Escuadrón ( Unidad ):
"""
Un enlazador es un escuadrón de más de una persona. También
puede incluir otros escuadrones enlazadores.
"""
def __init__ ( auto ):
auto . _unidades = []
def print ( self ) -> Ninguno :
print ( "Squad {} (" . format ( self . __hash__ ()), end = ' ' )
for u in self . _units :
u . print ()
print ( ')' )
def add ( self , unidad : Unidad ) -> Ninguno :
"""
Agregando una nueva unidad
:param unidad: unidad (puede ser base o constructor) """ self . _unidades . agregar ( unidad ) unidad . print () print ( 'escuadrón unido {} ' . format ( self . __hash__ ())) print ()
def remove ( self , unit : Unit ) -> Ninguno :
"""
Quitar unidad del generador actual
:param unit: objeto de unidad """ for u in self . _unidades : si u == unidad : self . _unidades . eliminar ( u ) u . print () print ( 'unidad izquierda {} ' . format ( self . __hash__ ())) print () break else : unidad . print () print ( 'no encontrado en escuadrón {} ' . format ( self . __hash__ ())) print ()
if __name__ == '__principal__' :
print ( 'SALIDA:' )
equipo = Equipo ()
equipo . agregar ( Caballero ())
escuadrón . agregar ( Caballero ())
escuadrón . add ( Archer ())
espadachín = Swordsman ()
escuadrón . añadir escuadrón ( espadachín )
. eliminar el escuadrón ( espadachín ) . print () escuadrón_grande = Escuadrón () escuadrón_grande . agregar ( Espadachín ()) escuadrón_grande . agregar ( Espadachín ()) escuadrón_grande . agregar ( escuadrón ) escuadrón_grande . imprimir ()
'''
SALIDA:
Knight se ha unido -9223363262492103834
caballero se unió al escuadrón -9223363262492103834
arquero se unió al escuadrón -9223363262492103834
espadachín se unió al escuadrón -9223363262492103834
el espadachín salió de la escuadra -9223363262492103834
Escuadrón -9223363262492103834 (caballero caballero arquero)
espadachín se unió al escuadrón 8774362671992
espadachín se unió al escuadrón 8774362671992
Escuadrón -9223363262492103834 (caballero caballero arquero)
se unió al escuadrón 8774362671992
Squad 8774362671992 ( espadachín espadachín Squad -9223363262492103834 ( caballero caballero arquero )
)
'''
Ejemplo de PHP5
código fuente PHP5
<?php
Componente de clase abstracta { protected $name ;
public function __construct ( $nombre )
{
$esto -> nombre = $nombre ;
}
visualización de funciones abstractas públicas (); }
class Composite extends Component
{
private $children = array ();
public function add ( Componente $componente )
{
$esto -> niños [ $componente -> nombre ] = $componente ;
}
función pública remove ( Componente $ componente )
{
unset ( $ esto -> niños [ $ componente -> nombre ]);
}
pantalla de función pública () { foreach ( $ esto -> niños como $ niño ) { $ niño -> pantalla (); } } }
class Leaf extiende Componente
{
visualización de función pública () { print_r ( $ esto -> nombre ); } }
// Crear una estructura de árbol
$root = new Composite ( "root" );
$raíz -> agregar ( nueva Hoja ( "Hoja A" ));
$raíz -> agregar ( nueva Hoja ( "Hoja B" ));
$comp = nuevo compuesto ( "CompositeX" );
$comp -> agregar ( nueva Hoja ( "Hoja XA" ));
$comp -> agregar ( nueva Hoja ( "Hoja XB" ));
$raíz -> agregar ( $comp );
$raíz -> agregar ( nueva Hoja ( "Hoja C" ));
// Agregar y eliminar una hoja
$hoja = hoja nueva ( " Hoja D" ); $raíz -> agregar ( $hoja ); $raíz -> eliminar ( $hoja );
// Visualización recursiva del árbol
$raíz -> visualización ();
?>
Ejemplo de enlazador de iterador externo de PHP5
código fuente PHP5
/**
* Patrón Composer con iterador externo
* El iterador usa la recursividad para recorrer el árbol de elementos
*/
namespace compositeIterator {
/**
* El cliente usa la interfaz AComponent para trabajar con objetos.
* La interfaz AComponent define la interfaz para todos los componentes: tanto combinaciones como nodos hoja.
* AComponent puede implementar el comportamiento predeterminado para add() remove() getChild() y otras operaciones
*/
clase abstracta AComponent {
public $nombrePropiedadPersonalizada ;
public $customPropertyDescription ;
/**
* @param AComponent $componente
*/
public function add ( $componente )
{
throw new \Exception ( "Operación no admitida" );
}
/**
* @param AComponent $componente
*/
public function remove ( $componente )
{
throw new \Exception ( "Operación no admitida" );
}
/**
* @param int $int
*/
public function getChild ( $int )
{
throw new \Exception ( "Operación no admitida" );
}
/**
* @return IPhpLikeIterator
*/
función abstracta createIterator ();
public function operation1 ()
{
throw new \Exception ( "Operación no admitida" );
}
}
/**
* Leaf hereda los métodos add() remove() getChild(, que pueden no tener sentido para un nodo hoja.
* Aunque un nodo hoja puede considerarse un nodo con cero hijos
*
* Leaf define el comportamiento de los elementos de combinación Para ello, implementa las operaciones soportadas por Composite interface
*/
class Leaf extends AComponent
{
public function __construct ( $name , $description = '' )
{
$this -> customPropertyName = $name ;
$this -> customPropertyDescription = $ descripción ;
}
public function createIterator ()
{
return new NullIterator ();
}
public function operation1 ()
{
echo ( " \n Soy hoja { $this -> customPropertyName } , no quiero hacer la operación 1. { $this -> customPropertyDescription } " );
}
}
clase NullIterator implementa IPhpLikeIterator
{
public function valid ()
{
return ( false );
}
función pública siguiente ()
{
retorno ( falso );
}
public function actual ()
{
return ( null );
}
public function remove ()
{
throw new \CException ( 'operación no admitida' );
}
}
/**
* La interfaz Composite define el comportamiento de los componentes que tienen hijos y proporciona almacenamiento para ellos.
*
* El Composite también implementa operaciones relacionadas con Leaf. Algunos de ellos no pueden dejar de tener sentido para las combinaciones; en tales casos, se lanza una excepción.
*/
class Composite extiende AComponent
{
privado $_iterador = nulo ;
/**
* @var \ArrayObject AComponent[] $componentes para almacenar hijos de tipo AComponent
*/
public $componentes = null ;
public function __construct ( $name , $description = '' )
{
$this -> customPropertyName = $name ;
$this -> customPropertyDescription = $description ;
}
/**
* @param AComponent $componente
*/
public function add ( $componente )
{
if ( is_null ( $this -> components )) {
$this -> components = new \ArrayObject ;
}
$esto -> componentes -> agregar ( $componente );
}
public function remove ( $componente )
{
foreach ( $this -> components as $i => $c ) {
if ( $c === $component ) {
unset ( $this -> components [ $i ]);
}
}
}
public function getChild ( $int )
{
return ( $this -> components [ $int ]);
}
public function operation1 ()
{
echo " \n\n $this->customPropertyName $this->customPropertyDescription " ; echo " \n --------------------------------" ;
$iterador = $esto -> componentes -> getIterator ();
while ( $iterador -> válido ()) {
$componente = $iterador -> actual ();
$componente -> operación1 ();
$iterador -> siguiente ();
}
}
/**
* @return CompositeIterator
*/
public function createIterator ()
{
if ( is_null ( $this -> _iterator )) {
$this -> _iterator = new CompositeIterator ( $this -> components -> getIterator ());
}
retorno ( $esto -> _iterador );
}
}
/**
* Iterador compuesto recursivo
*/
class CompositeIterator implementa IPhpLikeIterator
{
público $ pila = matriz ();
/**
* @param \ArrayIterator $componentsIterator
*/
public function __construct ( $componentsIterator )
{
//$this->stack= new \ArrayObject;
$this -> stack [] = $componentsIterator ;
}
public function remove ()
{
throw new \CException ( 'operación no admitida' );
}
public function valid ()
{
if ( vacío ( $this -> stack )) {
return ( false );
} else {
/** @var $componentsIterator \ArrayIterator */
// obtener el primer elemento
$componentsIterator = array_shift ( array_values ( $this -> stack ));
if ( $componentsIterator -> valid ()) {
return ( true );
} else {
array_shift ( $this -> stack );
return ( $esto -> valido ());
}
}
}
public function next ()
{
/** @var $componentsIterator \ArrayIterator */
$componentsIterator = actual ( $this -> stack );
$componente = $componentesIterador -> actual ();
if ( $componente instancia de Composite ) {
array_push ( $this -> stack , $componente -> createIterator ());
}
$componentesIterador -> siguiente ();
//retorno($componente);
}
public function current ()
{
if ( $this -> valid ()) {
/** @var $componentsIterator \ArrayIterator */
// obtener el primer elemento
$componentsIterator = array_shift ( array_values ( $this -> stack )) ;
return ( $componentesIterator -> actual ());
} más {
retorno ( nulo );
}
}
}
/**
* Todos los iteradores deben implementar la interfaz Iterator.
* Esta interfaz es parte de la interfaz del iterador php estándar.
* Un iterador particular es responsable de administrar la posición de iteración actual en una colección particular.
*/
interface IPhpLikeIterator
{
/**
* @abstract
* @return boolean es el elemento actual
*/
public function valid ();
/**
* @abstract
* @return mixto mueve el cursor más lejos
*/
función pública siguiente ();
/**
* @abstract
* @return mixed obtiene el elemento actual
*/
public function current ();
/**
* elimina el elemento actual de la colección
* @abstract
* @return void
*/
public function remove ();
}
clase Cliente
{
/**
* @varAComponent
*/
public $topItem ;
public function __construct ( $topItem )
{
$this -> topItem = $topItem ;
}
public function printOperation1 ()
{
$this -> topItem -> operation1 ();
}
public function printOperation2 ()
{
echo " \n\n\n " ;
$iterador = $esto -> topItem -> createIterator ();
while ( $iterador -> válido ()) {
/** @var $componente AComponente */
$componente = $iterador -> actual ();
if ( strstr ( $component -> customPropertyName , 'leaf1' )) {
echo ( " \n Soy cliente, encontré leaf { $component -> customPropertyName } , lo dejaré aquí (para mi 'primera- colección de té de leafs). { $componente -> customPropertyDescription } " );
}
$iterador -> siguiente ();
}
}
}
prueba de
clase {
función estática pública ir () { $a = nuevo compuesto ( "c1" ); $b = nuevo compuesto ( "c2" ); $c = nuevo compuesto ( "c3" );
$topItem = nuevo compuesto ( "elemento superior" );
$elementosuperior -> agregar ( $a );
$elemento superior -> agregar ( $b );
$elementosuperior -> agregar ( $c );
$a -> agregar ( nueva Hoja ( "c1-hoja1" ));
$a -> agregar ( nueva Hoja ( "c1-hoja2" ));
$b -> agregar ( hoja nueva ( "c2-hoja1" )); $b -> agregar ( nueva Hoja ( "c2-hoja2" )); $b -> agregar ( hoja nueva ( "c2-hoja3" ));
$c -> agregar ( hoja nueva ( "c3-hoja1" )); $c -> agregar ( hoja nueva ( "c3-hoja2" ));
$cliente = nuevo Cliente ( $topItem );
$cliente -> imprimirOperacion1 ();
$cliente -> printOperation2 ();
}
}
prueba :: ir ();
}
Ejemplo de PHP5.4
Texto fuente en PHP5.4
<?php
interfaz IComponent {
pantalla de función (); }
rasgo TComponent
{
público $ nombre ;
public function __construct ( $nombre )
{
$esto -> nombre = $nombre ;
}
pantalla de función pública () { imprimir $ esto -> nombre . '<br>' . PHP_EOL ; } }
rasgo TComposite
{
use TComponent {
TComponent :: mostrar como displaySelf ;
}
protegido $ niños = matriz ();
public function add ( IComponent $item )
{
$this -> children [ $item -> name ] = $item ;
}
eliminación de función pública ( IComponent $elemento ) { unset ( $este -> niños [ $elemento -> nombre ]); }
visualización de funciones públicas () { $this -> displaySelf (); foreach ( $this -> children as $child ) { $child -> display (); } } }
class Composite implementa IComponent
{
use TComposite ;
}
class Leaf implementa IComponent
{
use TComponent ;
}
$raíz = nuevo compuesto ( "raíz" );
$raíz -> agregar ( nueva Hoja ( "Hoja A" ));
$raíz -> agregar ( nueva Hoja ( "Hoja B" ));
$comp = nuevo compuesto ( "CompositeX" );
$comp -> agregar ( nueva Hoja ( "Hoja XA" ));
$comp -> agregar ( nueva Hoja ( "Hoja XB" ));
$raíz -> agregar ( $comp );
$raíz -> agregar ( nueva Hoja ( "Hoja C" ));
$hoja = nueva Hoja ( "Hoja D" );
$raíz -> agregar ( $hoja );
$raíz -> eliminar ( $hoja );
$raíz -> mostrar ();
Texto fuente en lenguaje CoffeeScript
Un ejemplo de un espacio en blanco de un motor de física simple
#
Clase de componente PObject
collide: (pObj) ->
addChild: (pObj) ->
rmChild: (índice) ->
getChild: (índice) ->
# La
clase hoja PShape extiende la colisión de PObject
: (pObj) ->
# ...
# La
clase compuesta PCollection extiende el constructor PObject
: ->
@children = []
colisionar: (pObj) ->
hijo . colisionar ( pObj ) para niño en @ niños
devuelve @
addChild: (pObj) ->
@niños . push ( pObj ) si pObj instancia de PObject
return @
rmChild: (índice) ->
@niños . empalme ( índice , 1 )
retorno @
getChild: (índice) ->
@niños [ índice ]
Texto fuente en lenguaje VB.NET
programa de clase
Subprincipal compartido ( )
' Crear una estructura de árbol
Dim root As Component = New Composite ( "raíz" )
raíz _ Agregar ( Nueva hoja ( "Hoja A" ))
raíz . Agregar ( Nueva hoja ( "Hoja B" ))
Dim comp As Component = Nuevo compuesto ( "Compuesto X" )
borrador _ Añadir ( Nueva Hoja ( "Hoja XA" ))
comp . Agregar ( Nueva hoja ( "Hoja XB" ))
raíz . Añadir ( comp )
raíz . Agregar ( Nueva hoja ( "Hoja C" ))
' Agregar y eliminar una
raíz de hoja Dim leaf As New Leaf ( "Hoja D" )
. Agregue la raíz ( hoja ) . Quitar ( hoja )
' Muestra recursivamente la
raíz del árbol . Pantalla ( 1 )
'Esperar a la
Consola del usuario . leer ()
End Sub
End Class
''' <summary>
''' Component -
''' </summary>
''' <li>
''' <lu>declara una interfaz para objetos componibles;</lu>
''' <lu>proporciona una interfaz adecuada operaciones predeterminadas de implementación,
''' comunes a todas las clases;</lu>
''' <lu>declara una interfaz para acceder y manipular hijos;</lu>
''' <lu>define una interfaz para acceder al padre de un componente en una estructura recursiva
''' y opcionalmente la implementa. Esta característica es opcional;</lu>
''' </li>
MustInherit Class Component
Protected name As String
'Constructor
Public Sub New ( ByVal name As String )
Me . nombre = nombre
End Sub
Public MustOverride Sub Add ( ByVal c As Component )
Public MustOverride Sub Remove ( ByVal c As Component )
Public MustOverride Sub Display ( ByVal depth As Integer )
End Class
''' <summary>
''' Composite: un objeto compuesto
''' </summary>
''' <li>
''' <lu>define el comportamiento de los componentes que tienen hijos;</lu>
''' < lu >almacena los componentes secundarios;</lu>
''' <lu>implementa la gestión secundaria y las operaciones relacionadas con la interfaz
''' de la clase <see cref="Component"/></lu>
''' </li>
Class Composite
Hereda el componente
Private children como New ArrayList ()
'Constructor
Public Sub New ( nombre ByVal As String ) MyBase . Nuevo ( nombre ) End Sub
Public Overrides Sub Add ( componente ByVal As Component ) hijos . Agregar ( componente ) End Sub
Public Overrides Sub Remove ( ByVal componente As Component )
hijos . Quitar ( componente )
End Sub
Public Overrides Sub Display ( ByVal depth As Integer )
Console . WriteLine ( Nueva cadena ( "-"c , profundidad ) y nombre )
' Muestra de forma recursiva los nodos secundarios
para cada componente como componente en el componente secundario
. Mostrar ( profundidad + 2 ) Next End Sub End Class
''' <summary>
''' Leaf - leaf
''' </summary>
''' <remarks>
''' <li>
''' <lu>representa el nodo hoja de la composición y no tiene hijos;< /lu>
''' <lu>define el comportamiento de los objetos primitivos en la composición;</lu>
''' </li>
''' </remarks>
Class Leaf
Inherits Component
'Constructor
Public Sub New ( nombre ByVal As String ) MyBase . Nuevo ( nombre ) End Sub
Public Overrides Sub Add ( ByVal c As Component )
Console . WriteLine ( "No se puede agregar a una hoja" )
End Sub
Public Overrides Sub Remove ( ByVal c As Component )
Console . WriteLine ( "No se puede eliminar de una hoja" )
End Sub
Public Overrides Sub Display ( ByVal depth As Integer )
Console . WriteLine ( Nueva cadena ( "-"c , profundidad ) y nombre )
End Sub
End Class
Ejemplo de Delphi
Texto fuente en Delphi
programa PatrónCompuesto ;
{$CONSOLA DE TIPO DE APLICACIÓN}
utiliza
SysUtils , Contnrs ;
type
TCustomLetter = class
procedimiento público
Draw ; virtuales ; abstracto ; fin ;
escriba
TLetter = clase ( TCustomLetter )
private
FLetter : Char ;
constructor público
Create ( aLetter : Char ) ; procedimiento Dibujar ; anular ; fin ;
constructor TLetra . Crear ( unaCarta : Carácter ) ;
comenzar
FLetra := aLetra ;
fin ;
procedimientoTCarta ._ _ dibujar ;
comenzar a
escribir ( FLetter ) ;
fin ;
escriba
TWord = class ( TCustomLetter )
private
FWord : String ;
constructor público
Create ( unaPalabra : String ) ; procedimiento Dibujar ; anular ; fin ;
constructor TWord . Crear ( unaPalabra : Cadena ) ;
comenzar
FPalabra := unaPalabra ;
fin ;
procedimiento TWord . dibujar ;
comenzar a
escribir ( FWord ) ;
fin ;
escriba
TText = class ( TCustomLetter )
private
FList : TObjectList ;
constructor público
Crear ; destructor Destruir ; anular ;
procedimiento Añadir ( unaCartaPersonalizada : TCartaPersonalizada ) ;
procedimiento Dibujar ; anular ;
fin ;
constructor TText . crear ;
comenzar
heredado ;
FList := TObjectList . crear ;
fin ;
destructor TText . destruir ;
comenzar
FList . Gratis ;
heredado ;
fin ;
procedimiento TTexto . Agregar ( unaCartaPersonalizada : TCartaPersonalizada ) ;
comenzar
FList . Add ( unaCartaPersonalizada ) ;
fin ;
procedimiento TTexto . dibujar ;
var
vi : Entero ;
empezar
por vI := 0 a Pred ( FList . Count ) do
TLetter ( FList [ vI ]) . dibujar ;
fin ;
var
vRootText , vSubText : TText ;
comenzar
vRootText := TText . crear ;
vSubTexto := TTexto . crear ;
prueba
vSubText . Agregar ( TLetter . Create ( '!' )) ;
vSubtexto . Agregar ( TLetter . Create ( '!' )) ;
vSubtexto . Agregar ( TLetter . Create ( '!' )) ;
vSubtexto . Agregar ( TWord . Create ( ' =)' )) ;
vRootText . Agregar ( TLatter.Create ( ' H' ) ) ; vRootText . Agregar ( TLetter.Create ( ' E ' )) ; vRootText . Agregar ( TLatter.Create ( ' L' ) ) ; vRootText . Agregar ( TLatter.Create ( ' L' ) ) ; vRootText . Agregar ( TLatter.Create ( ' O' ) ) ; vRootText . Agregar ( TLetter . Create ( ' ' )) ; vRootText . Agregar ( TWord . Crear ( 'Mundo' )) ; vRootText . Añadir ( vSubTexto ) ;
vRootText . dibujar ;
finalmente
vRootText . destruir ;
fin ;
Leerln ;
fin _
Código fuente JavaScript
función Componente () {
este . nombre = '' ;
esto _ valor = 0 ;
esto _ ejecutar = función () { };
}
function Leaf ( nombre , valor ) {
this . nombre = nombre ;
esto _ valor = valor ;
esto _ ejecutar = función () {
devuelve esto . valor ;
};
}
hoja _ prototipo = Objeto . crear ( Componente . prototipo );
hoja _ prototipo _ constructor = hoja ;
function Compuesto ( nombre ) {
var self = this ;
var niños = [];
esto _ nombre = nombre ;
esto _ sumar = función ( componente ) {
niños . empujar ( componente );
};
esto _ remove = function ( nombre del componente ) {
var newChildren = [];
niños _ forEach ( function ( componente ) {
if ( componente . nombre !== nombre del componente ) {
newChildren . push ( componente );
}
});
niños = nuevosNiños ;
};
esto _ ejecutar = función () {
niños . forEach ( función ( componente ) {
self . valor = ( self . valor || 0 ) + componente . ejecutar ();
});
devolverse a uno mismo . valor ;
};
}
compuesto _ prototipo = Objeto . crear ( Componente . prototipo );
compuesto _ prototipo _ constructor = Compuesto ;
// Aplicación
var cocina = new Composite ( 'Cocina' );
cocina _ agregar ( nueva hoja ( 'Sección superior' , 5200 ) );
cocina _ add ( nueva hoja ( 'Sección doble superior' , 10000 ) );
cocina _ agregar ( nueva hoja ( 'Sección inferior' , 4500 ) );
cocina _ agregar ( nueva hoja ( 'Sección de la esquina inferior' , 7800 ) );
var equipo = nuevo Compuesto ( 'Equipo' );
equipo _ add ( nueva Hoja ( 'Estufa de gas' , 26400 ) );
equipo _ agregar ( nueva Hoja ( 'Refrigerador' , 32300 ) );
equipo _ agregar ( nueva hoja ( 'Lavavajillas' , 21600 ) );
cocina _ añadir ( equipo );
consola _ log ( 'Total: ' + cocina . ejecutar () + ' RUB' );
Ejemplo de Swift
Código fuente rápido
Artículo de protocolo {
id de var : UInt32 { obtener }
nombre de var : Cadena { obtener }
descripción de la función () -> String
}
botón de clase : elemento {
id de var : UInt32 = arc4random ()
nombre de var : Cadena = "Botón"
descripción de la función () -> String {
return "ID: \( id ) | \( nombre ) "
}
}
Etiqueta de clase : Artículo {
id de var : UInt32 = arc4random ()
nombre de var : String = "Etiqueta"
descripción de la función () -> String {
return "ID: \( id ) | \( nombre ) "
}
}
vista de clase : elemento {
var componentes : [ Artículo ] = []
id de var : UInt32 = arc4random ()
nombre de var : String = "Ver"
func desctiption () -> String {
componentes de retorno . reducir ( "" , { " \( $0 ) \( $1 . descripción ()) " }) }
func add ( elemento : elemento ) {
componentes . agregar ( elemento )
}
func remove ( item : Item ) {
if let index = components . firstIndex ( donde : { $0 . id == artículo . id }) {
componentes . eliminar ( en : índice )
}
}
}
// Usar compuesto
let boton = boton ()
print ( boton.descripción ( ) )
dejar ver = Ver ()
ver . añadir ( elemento : botón ())
vista . agregar ( elemento : Etiqueta ())
imprimir ( ver. descripción ( ) )
Enlaces