Linker (model de design)
Versiunea actuală a paginii nu a fost încă examinată de colaboratori experimentați și poate diferi semnificativ de
versiunea revizuită pe 9 mai 2016; verificările necesită
16 modificări .
Modelul compozit este un model de design structural care combină obiecte într- o structură arborescentă pentru a reprezenta o ierarhie de la particular la întreg. Linker-ul permite clienților să acceseze obiecte individuale și grupuri de obiecte în același mod.
Scop
Modelul definește o ierarhie de clase care pot consta simultan din obiecte primitive și complexe, simplifică arhitectura clientului și facilitează procesul de adăugare a noilor tipuri de obiecte.
Descriere
Șablon de diagramă
UML :
Exemple de implementare
Exemplu Java
Sursa Java
import java.util.List ;
import java.util.ArrayList ;
/** „Componentă” */
interfață Grafic {
//Tipărește graficul.
public void print ();
}
/** „Compozit” */
clasa CompositeGraphic implementează Graphic {
//Colecție de grafice pentru copii.
Private List < Graphic > mChildGraphics = new ArrayList < Graphic > ();
//Tipărește graficul.
public void print () {
for ( Grafic grafic : mChildGraphics ) {
grafic . imprimare ();
}
}
//Adaugă graficul la compoziție.
public void add ( Grafic grafic ) {
mChildGraphics . adauga ( grafic );
}
//Elimină graficul din compoziție.
public void remove ( grafică grafică ) {
mChildGraphics . elimina ( grafic );
}
}
/** „Frunză” */
clasa Ellipse implementează graficul {
//Tipărește graficul.
public void print () {
System . afară . println ( "Elipsa" );
}
}
/** Client */
program de clasă publică {
public static void main ( String [] args ) {
//Inițializați patru elipse
Elipse elipse1 = new Elipse ( ); Elipse elipse2 = elipsa noua (); Elipse elipse3 = elipsa noua (); Elipse elipse4 = elipsă nouă ();
//Inițializați trei grafice compuse
CompositeGraphic graphic = new CompositeGraphic ();
CompositeGraphic graphic1 = nou CompositeGraphic ();
CompositeGraphic graphic2 = nou CompositeGraphic ();
//Compune grafica
graphic1 . adaugă ( elipse1 );
grafic1 . adaugă ( elipse2 );
grafic1 . adaugă ( elipse3 );
grafic2 . adaugă ( elipse4 );
grafic . adauga ( grafic1 );
grafic . adauga ( grafic2 );
//Tipărește graficul complet (de patru ori șirul „Elipse”).
grafic . imprimare ();
}
}
Exemplu în C#
Text sursă în C#
class MainApp
{
static void Main ()
{
// Creați o structură arborescent
Composite root = new Composite ( "root" );
rădăcină . Adăugați ( frunză nouă ( „Frunza A” )); rădăcină . Adăugați ( frunză nouă ( „Frunza B” ));
Composite comp = new Composite ( "CompositeX" );
comp . Adăugați ( frunză nouă ( „Frunză XA” )); comp . Adăugați ( new Leaf ( "LeafXB" )); rădăcină . Adăugați ( comp ); rădăcină . Adăugați ( frunză nouă ( „Frunza C” ));
// Adăugați și îndepărtați o frunză
Leaf leaf = new Leaf ( "Leaf D" );
rădăcină . Adăugați ( frunză );
rădăcină . Îndepărtați ( frunza );
// Afișează recursiv
rădăcina arborelui . afișaj ( 1 );
// Așteptați
Consola utilizatorului . citește ();
}
}
/// <summary>
/// Component - component
/// </summary>
/// <li>
/// <lu>declară o interfață pentru obiectele componabile;</lu>
/// <lu>oferă o operațiuni implicite de implementare adecvate,
/// comune tuturor claselor;</lu>
/// <lu>declară o interfață pentru accesarea și manipularea copiilor;</lu>
/// <lu>definește o interfață pentru accesarea părintelui componentei într-o structură recursivă
/// și opțional o implementează. Această caracteristică este opțională;</lu>
/// </li>
abstract class Component
{
protected string name ;
// Constructor
public Component ( string name )
{
this . nume = nume ;
}
public abstract void Afișare ( int depth );
}
/// <summary>
/// Compozit - un obiect compus
/// </summary>
/// <li>
/// <lu>definește comportamentul componentelor care au copii;</lu>
/// < lu >stochează componente copii;</lu>
/// <lu>implementează operațiuni legate de managementul copiilor și interfața /// ale
clasei <see cref="Component"/></lu>
/// </li>
Compozit : Component { private List < Component > children = new List < Component >();
// Constructor
public Compozit ( nume șir ) : bază ( nume ) { }
public void Adaugă ( componentă componentă )
{
copii . Adăugați ( componentă );
}
public void Eliminare ( componentă componentă )
{
copii . Eliminați ( componenta );
}
public override void Display ( int depth )
{
Consolă . WriteLine ( șir nou ( '-' , adâncime ) + nume );
// Afișează recursiv nodurile copil
foreach ( Component component in children )
{
component . Afișaj ( adâncime + 2 );
}
}
}
/// <summary>
/// Leaf - leaf
/// </summary>
/// <remarks>
/// <li>
/// <lu>reprezintă nodul frunză al compoziției și nu are copii;< /lu>
/// <lu>definește comportamentul obiectelor primitive în compoziție;</lu>
/// </li>
/// </remarks>
class Leaf : Component
{
// Constructor
public Leaf ( string name ) : baza ( nume )
{
}
public override void Display ( int depth )
{
Consolă . WriteLine ( șir nou ( '-' , adâncime ) + nume ); } }
Exemplu C++
Text sursă în C++
#include <iostream>
#include <listă>
#include <algoritm>
#include <memorie>
clasa IText {
public :
typedef std :: shared_ptr < IText > SPtr ;
virtual void draw () = 0 ;
virtual void add ( const SPtr & ) {
throw std :: runtime_error ( "IText: Nu se poate adăuga la o frunză" );
}
virtual void remove ( const SPtr & ){
throw std :: runtime_error ( "IText: Nu se poate elimina dintr-o frunză" );
}
};
clasa CompositeText : public IText {
public :
void add ( const SPtr & sptr ){
copii_ . push_back ( sptr );
}
void remove ( const SPtr & sptr ){
copii_ . elimina ( sptr );
}
void replace ( const SPtr & oldValue , const SPtr & newValue ){
std :: înlocuiți ( copii_ . început ( ) , copii_ . sfârșit (), Valoare veche , Valoare nouă );
}
virtual void draw (){
pentru ( SPtr & sptr : copii_ ){
sptr -> draw ();
}
}
privat :
std :: list < SPtr > children_ ;
};
Scrisoare de clasă : public IText {
public :
Litera ( car c ) : c_ ( c ) {}
virtual void draw (){
std :: cout << c_ ;
}
privat :
char c_ ;
};
int main (){
Propoziție CompositeText ;
IText :: SPtr lSpace ( literă nouă ( ' ' ));
IText :: SPtr lExcl ( literă nouă ( '!' ));
IText :: SPtr lComma ( literă nouă ( ',' ));
IText :: SPtr lNewLine ( scrisoare nouă ( '\n' ));
IText :: SPtr lH ( literă nouă ( „H” )); // litera 'H' IText :: SPtr le ( literă nouă ( 'e' )); // litera 'e' IText :: SPtr ll ( literă nouă ( 'l' )); // litera 'l' IText :: SPtr lo ( literă nouă ( 'o' )); // litera 'o' IText :: SPtr lW ( literă nouă ( 'W' )); // litera 'W' IText :: SPtr lr ( literă nouă ( 'r' )); // litera 'r' IText :: SPtr ld ( literă nouă ( 'd' )); // litera 'd' IText :: SPtr li ( literă nouă ( 'i' )); // litera „i”
IText :: SPtr wHello ( nou CompositeText );
wSalut -> adauga ( lH );
wHello -> add ( le );
wSalut -> adaugă ( ll );
wSalut -> adaugă ( ll );
wHello -> adaugă ( lo );
IText :: SPtr wWorld ( compositeText nou ); // cuvântul "World" wWorld -> adaugă ( lW );
lume -> adaugă ( lo );
wWorld -> add ( lr );
lume -> adaugă ( ll );
wWorld -> adaugă ( ld );
propoziție . adauga ( wHello );
propoziție . adauga ( lVirgula );
propoziție . adăugați ( lSpațiu );
propoziție . adauga ( lumea );
propoziție . adaugă ( lExcl );
propoziție . adaugă ( lNewLine );
propoziție . trage (); // afișează „Bună, lume!\n”
IText :: SPtr wHi ( nou CompositeText ); // cuvântul "Hi" wHi -> add ( lH );
whi -> add ( li );
propoziție . înlocuiți ( wHello , wHi );
propoziție . trage (); // afișează „Bună, lume!\n”
propoziție . elimina ( lumea );
propoziție . eliminați ( lSpace );
propoziție . elimina ( lComma );
propoziție . trage (); // afișează „Bună!\n”
returnează 0 ;
}
Exemplu în D
Text sursă în limba D
import std . stdio ;
clasa abstracta TIInfo
{
protected :
nume sir ;
public :
void Info ();
}
class TFile : TIInfo
{
protected :
uint size ;
public :
this ( șir const theName , uint theSize ) { name = theName ; dimensiune = theSize ; }
void Info ()
{
writefln ( "%s\t%d" , nume , dimensiune );
}
}
clasa TDir : TInfo
{
protected :
TInfo [] info ;
public :
acest ( șir const theName ) { name = theName ; }
void Info ()
{
writefln ( "[%s]" , nume );
foreach ( f ; info )
{
f . info ();
}
}
void Adaugă ( TIInfo theInfo )
{
info ~= theInfo ;
}
}
void main ()
{
TDir first = new TDir ( "primul" );
primul . Adăugați ( fișier nou ( " a.txt " , 100 )); primul . Adăugați ( TFile nou ( „b.txt” , 200 )); primul . Adăugați ( TFile nou ( " c.txt " , 300 ));
TDir secundă = nou TDir ( „secunda” );
al doilea . Adăugați ( TFile nou ( " d.txt " , 400 )); al doilea . Adăugați ( fișier nou ( „ e.txt ” , 500 ));
TDir root = new TDir ( „rădăcină” );
rădăcină . Adăugați ( primul );
rădăcină . Adăugați ( secunda );
rădăcină . info ();
}
Exemplu Python
Cod sursă în Python
din abc import ABCMeta , abstractmethod
class Unit ( metaclass = ABCMeta ):
"""
O componentă abstractă, în acest caz este o unitate (o unitate poate
consta din unul sau mai mulți soldați)
"""
@abstractmethod
def print ( self ) -> None :
"""
Tipărire date componente
"""
trece
clasa Archer ( Unitate ):
"""
Archer
"""
def print ( self ) -> None :
print ( 'arcaș' , final = ' ' )
clasa Knight ( Unitate ):
"""
Knight
"""
def print ( self ) -> None :
print ( 'cavaler' , sfârşitul = '' )
clasa Spadasin ( unitate ):
"""
Spadasin
"""
def print ( self ) -> None :
print ( 'swordsman' , end = '' )
Class Squad ( Unitate ):
"""
Un linker este o echipă de mai multe persoane. Poate
include și alte echipe de linker.
"""
def __init__ ( self ):
sine . _unități = []
def print ( self ) -> None :
print ( " Squad {} (" . format ( self . __hash__ ()), end = ' ' )
for u in self . _units :
u . print ()
print ( ')' )
def add ( self , unit : Unit ) -> None :
"""
Adăugarea unei noi unități
:param unit: unit (poate fi de bază sau constructor) """ self . _unități . anexa ( unitate ) unitate . print () print ( 'echipă alăturată {} ' . format ( self . __hash__ ())) print ()
def remove ( self , unit : Unit ) -> None :
"""
Eliminați unitatea din constructorul curent
:param unit: unit object """ for u in self . _unități : dacă u == unitate : sine . _unități . elimina ( u ) u . print () print ( 'unitatea stângă {} ' . format ( self . __hash__ ())) print () break else : unitate . print () print ( 'nu găsit în echipă {} ' . format ( self . __hash__ ())) print ()
if __name__ == '__main__' :
print ( 'OUTPUT:' )
squad = Squad ()
squad . adaugă ( Knight ())
echipă . adaugă ( Knight ())
echipă . add ( Archer ())
swordsman = Swordsman ()
squad . adăuga ( spadasin )
echipă . elimina ( spadasin )
echipă . print ()
squad_big = Squad ()
squad_big . adaugă ( Swordsman ())
squad_big . adaugă ( Swordsman ())
squad_big . adauga ( echipă )
squad_big . imprimare ()
'''
IEȘIRE:
Knight s-a alăturat -9223363262492103834
Knight s-a alăturat echipei -9223363262492103834
arcaș s-a alăturat echipei -9223363262492103834
spadasin s-a alăturat echipei -9223363262492103834
spadasinul a părăsit echipa -9223363262492103834
Echipa -9223363262492103834 (cavaler cavaler arcaș)
spadasin la echipă 8774362671992
spadasin s-a alăturat echipei 8774362671992
Echipa -9223363262492103834 (cavaler cavaler arcaș)
s-a alăturat echipei 8774362671992
Echipa 8774362671992 ( Squad swordsman swordsman Squad -9223363262492103834 ( cavaler cavaler arcaș )
)
'''
Exemplu PHP5
Cod sursă PHP5
<?php
abstract class Component
{
protected $nume ;
function public __construct ( $nume )
{
$acest -> nume = $nume ;
}
afișarea funcției abstracte publice (); }
class Composite extinde Componenta
{
private $copii = matrice ();
public function add ( Componenta $componenta )
{
$aceasta -> copii [ $componenta -> nume ] = $componenta ;
}
public function remove ( Component $component )
{
unset ( $this -> children [ $component -> name ]);
}
public function display ()
{
foreach ( $this -> children as $child ) {
$child -> display ();
}
}
}
class Leaf extends Component
{
public function display ()
{
print_r ( $this -> name );
}
}
// Creați o structură arborescentă
$root = new Composite ( "rădăcină" );
$rădăcină -> adaugă ( frunză nouă ( „Frunza A” )); $rădăcină -> adaugă ( frunză nouă ( „Frunza B” ));
$comp = new Composite ( "CompositeX" );
$comp -> adaugă ( new Leaf ( "Leaf XA" ));
$comp -> adaugă ( new Leaf ( "Leaf XB" ));
$root -> add ( $comp );
$rădăcină -> adaugă ( frunză nouă ( „Frunza C” ));
// Adăugați și eliminați o frunză
$leaf = new Leaf ( "Frunza D" );
$radacina -> adauga ( $frunza );
$root -> remove ( $leaf );
// Afișează recursiv arborele
$root -> display ();
?>
Exemplu de linker iterator extern PHP5
Cod sursă PHP5
/**
* Model de compozitor cu iterator extern
* Iteratorul folosește recursiunea pentru a itera prin arborele de elemente
*/
namespace compositeIterator {
/**
* Clientul folosește interfața AComponent pentru a lucra cu obiecte.
* Interfața AComponent definește interfața pentru toate componentele: atât combinații, cât și nodurile frunză.
* AComponent poate implementa comportamentul implicit pentru add() remove() getChild() și alte operațiuni
*/
abstract class AComponent
{
public $customPropertyName ;
public $customPropertyDescription ;
/**
* @param AComponent $component
*/
public function add ( $component )
{
throw new \Exception ( "Operatie nesuportata" );
}
/**
* @param AComponent $component
*/
public function remove ( $component )
{
throw new \Exception ( "Operatie nesuportata" );
}
/**
* @param int $int
*/
public function getChild ( $int )
{
throw new \Exception ( "Operatie nesuportata" );
}
/**
* @return IPhpLikeIterator
*/
funcția abstractă createIterator ();
public function operation1 ()
{
throw new \Exception ( "Operatiune nesuportata" );
}
}
/**
* Leaf moștenește metodele add() remove() getChild(, care ar putea să nu aibă sens pentru un nod frunză.
* Deși un nod frunză poate fi considerat un nod cu zero copii
*
* Frunza definește comportamentul elementelor combinate Pentru a face acest lucru, implementează operațiunile suportate de interfața Composite
*/
class Leaf extends AComponent
{
public function __construct ( $name , $description = '' )
{
$this -> customPropertyName = $name ;
$this -> customPropertyDescription = $ descriere ;
}
public function createIterator ()
{
return new NullIterator ();
}
public function operation1 ()
{
echo ( " \n Sunt frunza { $this -> customPropertyName } , nu vreau sa fac operatia 1. { $this -> customPropertyDescription } " );
}
}
clasa NullIterator implementează IPhpLikeIterator
{
public function valid ()
{
return ( false );
}
public function next ()
{
return ( false );
}
public function current ()
{
return ( null );
}
public function remove ()
{
throw new \CException ( 'operațiune nesuportată' );
}
}
/**
* Interfața Composite definește comportamentul componentelor care au copii și asigură stocarea acestora.
*
* Compozitul implementează și operațiuni legate de frunze. Unele dintre ele nu pot să nu aibă sens pentru combinații; în astfel de cazuri se aruncă o excepție.
*/
class Composite extinde AComponent
{
privat $_iterator = null ;
/**
* @var \ArrayObject AComponent[] $componente pentru a stoca copii de tip AComponent
*/
public $components = null ;
function public __construct ( $nume , $descriere = '' )
{
$this -> customPropertyName = $nume ;
$this -> customPropertyDescription = $descriere ;
}
/**
* @param AComponent $component
*/
public function add ( $component )
{
if ( is_null ( $this -> components )) {
$this -> components = new \ArrayObject ;
}
$this -> components -> append ( $component );
}
public function remove ( $component )
{
foreach ( $this -> componente ca $i => $c ) {
if ( $c === $component ) {
unset ( $this -> componente [ $i ]);
}
}
}
function public getChild ( $int )
{
return ( $this -> componente [ $int ]);
}
public function operation1 ()
{
echo " \n\n $this->customPropertyName $this->customPropertyDescription " ; ecou " \n --------------------------------" ;
$iterator = $this -> componente -> getIterator ();
while ( $iterator -> valid ()) {
$component = $iterator -> curent ();
$componenta -> operatiune1 ();
$iterator -> următorul ();
}
}
/**
* @return CompositeIterator
*/
public function createIterator ()
{
if ( is_null ( $this -> _iterator )) {
$this -> _iterator = new CompositeIterator ( $this -> componente -> getIterator ());
}
return ( $this -> _iterator );
}
}
/**
* Iterator recursiv compus
*/
clasa CompositeIterator implementează IPhpLikeIterator
{
public $stiva = matrice ();
/**
* @param \ArrayIterator $componentsIterator
*/
public function __construct ( $componentsIterator )
{
//$this->stack= new \ArrayObject;
$this -> stack [] = $componentsIterator ;
}
public function remove ()
{
throw new \CException ( 'operațiune nesuportată' );
}
function public valid ()
{
if ( empty ( $this -> stack )) {
return ( false );
} else {
/** @var $componentsIterator \ArrayIterator */
// obține primul element
$componentsIterator = array_shift ( array_values ( $this -> stack ));
if ( $componentsIterator -> valid ()) {
return ( true );
} else {
array_shift ( $this -> stack );
return ( $this -> valid ());
}
}
}
public function next ()
{
/** @var $componentsIterator \ArrayIterator */
$componentsIterator = curent ( $this -> stack );
$component = $componentsIterator -> curent ();
if ( $component instanceof Composite ) {
array_push ( $this -> stack , $component -> createIterator ());
}
$componentsIterator -> next ();
//return($component);
}
funcția publică curent ()
{
dacă ( $this -> valid ()) {
/** @var $componentsIterator \ArrayIterator */
// obține primul element
$componentsIterator = array_shift ( array_values ( $this -> stack )) ;
return ( $componentsIterator -> curent ());
} else {
return ( null );
}
}
}
/**
* Interfața Iterator trebuie implementată de toți iteratorii.
* Această interfață face parte din interfața standard php iterator.
* Un anumit Iterator este responsabil pentru gestionarea poziției curente de iterație într-o anumită colecție.
*/
interface IPhpLikeIterator
{
/**
* @abstract
* @return boolean este elementul curent
*/
public function valid ();
/**
* @abstract
* @return mixt muta cursorul mai departe
*/
public function next ();
/**
* @abstract
* @return mixed obține elementul curent
*/
public function current ();
/**
* elimina elementul curent al colecției
* @abstract
* @return void
*/
public function remove ();
}
clasă Client
{
/**
* @varAComponent
*/
public $topItem ;
function public __construct ( $topItem )
{
$this -> topItem = $topItem ;
}
public function printOperation1 ()
{
$this -> topItem -> operation1 ();
}
public function printOperation2 ()
{
echo " \n\n\n " ;
$iterator = $this -> topItem -> createIterator ();
while ( $iterator -> valid ()) {
/** @var $component AComponent */
$component = $iterator -> curent ();
if ( strstr ( $component -> customPropertyName , 'leaf1' )) {
echo ( " \n Sunt Client, am găsit frunza { $component -> customPropertyName } , o voi lăsa aici (pentru "primul meu- colecția de ceai a frunzelor). { $component -> customPropertyDescription } " );
}
$iterator -> următorul ();
}
}
}
class Test
{
public static function go ()
{
$a = new Composite ( "c1" );
$b = nou Compozit ( "c2" );
$c = nou Compozit ( "c3" );
$topItem = nou Compozit ( "articol de sus" );
$topItem -> adaugă ( $a );
$topItem -> adaugă ( $b );
$topItem -> adaugă ( $c );
$a -> adaugă ( frunză nouă ( "c1-leaf1" )); $a -> adaugă ( frunză nouă ( "c1-leaf2" ));
$b -> adaugă ( frunză nouă ( "c2-leaf1" )); $b -> adaugă ( frunză nouă ( "c2-leaf2" )); $b -> adaugă ( frunză nouă ( "c2-leaf3" ));
$c -> adaugă ( frunză nouă ( "c3-leaf1" )); $c -> adaugă ( frunză nouă ( "c3-leaf2" ));
$client = client nou ( $topItem ); $client -> printOperation1 (); $client -> printOperation2 (); } }
test :: du-te ();
}
Exemplu PHP5.4
Textul sursă în PHP5.4
<?php
interfata IComponent {
function display ();
}
caracteristica TComponent
{
public $nume ;
function public __construct ( $nume )
{
$acest -> nume = $nume ;
}
public function display ()
{
print $this -> name . „<br>” . PHP_EOL ;
}
}
caracteristică TComposite
{
folosește TComponent {
TComponent :: afișare ca displaySelf ;
}
protected $children = matrice ();
function public add ( IComponent $item )
{
$this -> children [ $item -> nume ] = $item ;
}
public function remove ( IComponent $item )
{
unset ( $this -> copii [ $item -> nume ]);
}
public function display ()
{
$this -> displaySelf ();
foreach ( $this -> children as $child ) {
$child -> display ();
}
}
}
class Composite implemente IComponent
{
use TComposite ;
}
clasa Leaf implementează IComponent
{
folosește TComponent ;
}
$root = new Composite ( "rădăcină" );
$rădăcină -> adaugă ( frunză nouă ( „Frunza A” )); $rădăcină -> adaugă ( frunză nouă ( „Frunza B” ));
$comp = new Composite ( "CompositeX" );
$comp -> adaugă ( new Leaf ( "Leaf XA" ));
$comp -> adaugă ( new Leaf ( "Leaf XB" ));
$root -> add ( $comp );
$rădăcină -> adaugă ( frunză nouă ( „Frunza C” ));
$frunză = frunză nouă ( „Frunză D” ); $radacina -> adauga ( $frunza ); $root -> remove ( $leaf );
$rădăcină -> afișare ();
Text sursă în limbajul CoffeeScript
Un exemplu de semifabricat al unui motor fizic simplu
#
Clasa componentei PObject
ciocnire: (pObj) ->
addChild : (pObj) ->
rmChild : (index) ->
getChild : (index) ->
#
Clasa frunzelor PShape extinde PObject
collide : (pObj) ->
# ...
#
Clasa compusă PCollection extinde constructorul PObject
: ->
@children = []
ciocnire : (pObj) ->
copil . ciocnire ( pObj ) pentru copil în @children
return @
addChild : (pObj) ->
@children . push ( pObj ) dacă pObj instanceof PObject
return @
rmChild : (index) ->
@copii . splice ( index , 1 )
return @
getChild : (index) ->
@children [ index ]
Text sursă în limba VB.NET
programul clasei
Subprincipal comun ( )
' Creați o structură arborescentă
Dim root As Component = New Composite ( „rădăcină” )
rădăcină . Adăugați ( Frunză nouă ( „Frunză A” )) rădăcină . Adăugați ( Frunză nouă ( „Frunza B” ))
Dim comp As Component = New Composite ( "Compozit X" )
comp . Adăugați ( Frunză nouă ( „Frunză XA” ) ) comp . Adăugați ( New Leaf ( "Leaf XB " ) ) rădăcină . Adăugați ( comp ) rădăcină . Adăugați ( Frunză nouă ( „Frunza C” ))
' Adăugați și îndepărtați o frunză
Dim leaf As New Leaf ( "Frunza D" )
rădăcină . Adăugați rădăcină ( frunză )
. Îndepărtați ( frunza )
' Afișează recursiv
rădăcina arborelui . Afișaj ( 1 )
' Așteptați
Consola utilizator . citeste ()
End Sub
End Class
''' <summary>
''' Componentă -
''' </summary>
''' <li>
''' <lu>declară o interfață pentru obiecte componabile;</lu>
''' <lu>oferă o interfață adecvată operațiuni implicite de implementare,
''' comune tuturor claselor;</lu>
''' <lu>declară o interfață pentru accesarea și manipularea copiilor;</lu>
''' <lu>definește o interfață pentru accesarea părintelui unei componente în o structură recursivă
''' și opțional o implementează. Această caracteristică este opțională;</lu>
''' </li>
MustInherit Class Component
Nume protejat ca șir
' Constructor
Public Sub Nou ( Numele ByVal As String ) Eu . nume = nume End Sub
Public MustOverride Sub Adăugare ( ByVal c ca componentă )
Public MustOverride Sub Remove ( ByVal c ca componentă )
Public MustOverride Sub Display ( ByVal depth As Integer )
End Class
''' <summary>
''' Compozit - un obiect compozit
''' </summary>
''' <li>
''' <lu>definește comportamentul componentelor care au copii;</lu>
''' < lu >stochează componente secundare;</lu>
''' <lu>implementează managementul copiilor și operațiunile legate de interfață
''' din clasa <see cref="Component"/></lu>
''' </li>
Class Composite
Moștenește Componenta
Fii private ca New ArrayList ()
' Constructor
Public Sub New ( Nume ByVal As String ) MyBase . Nou ( nume ) End Sub
Public Overscrie sub Adaugă ( componenta ByVal ca componentă ) copii . Adaugă ( componentă ) End Sub
Public Override Sub Remove ( componenta ByVal ca componentă ) copii . Eliminați ( componenta ) End Sub
Public Overscrie Sub Display ( ByVal depth As Integer )
Consola . WriteLine ( șir nou ( "-"c , adâncime ) și nume )
' Afișează recursiv nodurile copil
pentru fiecare componentă ca componentă în componenta copii
. Afișează ( adâncime + 2 ) Clasa de final secundară Next End
''' <summary>
''' Leaf - leaf
''' </summary>
''' <remarks>
''' <li>
''' <lu>reprezintă nodul frunză al compoziției și nu are copii;< /lu>
''' <lu>definește comportamentul obiectelor primitive din compoziție;</lu>
''' </li>
''' </remarks>
Class Leaf
Inherits Component
' Constructor
Public Sub New ( Nume ByVal As String ) MyBase . Nou ( nume ) End Sub
Public Overscrie Sub Add ( ByVal c As Component )
Console . WriteLine ( „Nu se poate adăuga la o frunză” )
End Sub
Public Overrides Sub Remove ( ByVal c As Component )
Console . WriteLine ( "Nu se poate elimina dintr-o frunză" )
End Sub
Public Overscrie Sub Display ( ByVal depth As Integer )
Consola . WriteLine ( șir nou ( "-" c , adâncime ) și nume ) End Sub End Class
Exemplu Delphi
Text sursă în Delphi
programul CompositePattern ;
{$APPTYPE CONSOLE}
folosește
SysUtils , Contnrs ;
tip
TCustomLetter = clasă
procedură publică
Draw ; virtual ; abstract ; sfârşitul ;
tip
TLetter = clasă ( TCustomLetter )
privat
FLetter : Char ;
constructor public
Create ( aLetter : Char ) ; procedura Remiză ; suprascrie ; sfârşitul ;
constructor TLetter . Creați ( aLetter : Char ) ;
începe
FLetter := aLetter ;
sfârşitul ;
procedurăScrisoare . _ trage ; începe Scrierea ( FLetter ) ; sfârşitul ;
tip
TWord = clasă ( TCustomLetter )
private
FWord : String ;
constructor public
Creare ( aWord : String ) ; procedura Remiză ; suprascrie ; sfârşitul ;
constructor TWord . Creare ( aWord : String ) ;
începe
FWord := aWord ;
sfârşitul ;
procedura DOUA . trage ;
începe
scrierea ( FWord ) ;
sfârşitul ;
tip
TText = clasă ( TCustomLetter )
privat
FList : TObjectList ;
constructor public
Creare ; destructor Distruge ; suprascrie ;
procedura Add ( aCustomLetter : TCustomLetter ) ;
procedura Remiză ; suprascrie ;
sfârşitul ;
constructor TText . a crea ;
începe
moștenit ;
FList := TObjectList . a crea ;
sfârşitul ;
destructor TText . Distruge ;
începe
FList . Gratuit ;
moștenit ;
sfârşitul ;
procedura TText . Adăugați ( aCustomLetter : TCustomLetter ) ;
începe
FList . Adăugați ( aCustomLetter ) ;
sfârşitul ;
procedura TText . trage ;
var
vI : Integer ;
începe
pentru vI := 0 la Pred ( FList . Count ) face
TLetter ( FList [ vI ] ) . trage ;
sfârşitul ;
var
vRootText , vSubText : TText ;
începe
vRootText := TText . a crea ;
vSubText := TText . a crea ;
încercați
vSubText . Adăugați ( TLetter . Create ( '!' )) ;
vSubText . Adăugați ( TLetter . Create ( '!' )) ;
vSubText . Adăugați ( TLetter . Create ( '!' )) ;
vSubText . Adăugați ( TWord . Create ( ' =) ' )) ;
vRootText . Adăugați ( TLetter.Create ( ' H' ) ) ; vRootText . Adăugați ( TLetter.Create ( ' E ' )) ; vRootText . Adăugați ( TLetter.Create ( ' L' ) ) ; vRootText . Adăugați ( TLetter.Create ( ' L' ) ) ; vRootText . Adăugați ( TLetter.Create ( ' O' ) ) ; vRootText . Adăugați ( TLetter . Create ( ' ' )) ; vRootText . Adăugați ( TWord . Create ( 'World' )) ; vRootText . Adăugați ( vSubText ) ;
vRootText . trage ;
în cele din urmă
vRootText . Distruge ;
sfârşitul ;
Readln ;
sfârşitul .
Cod sursă JavaScript
function Component () {
this . nume = '' ;
aceasta . valoare = 0 ;
aceasta . execute = function () { };
}
function Leaf ( nume , valoare ) {
this . nume = nume ;
aceasta . valoare = valoare ;
aceasta . execute = function () {
return this . valoare ;
};
}
frunza . prototip = Obiect . creați ( Componentă . prototip );
frunza . prototip . constructor = Leaf ;
function Composite ( nume ) {
var self = this ;
var copii = [];
aceasta . nume = nume ;
aceasta . add = function ( component ) {
copii . împingere ( componentă );
};
aceasta . remove = function ( componentName ) {
var newChildren = [];
copii . forEach ( function ( component ) {
if ( component . name !== componentName ) {
newChildren . push ( component );
}
});
copii = nouCopii ;
};
aceasta . execute = function () {
copii . forEach ( function ( component ) {
self . value = ( self . value || 0 ) + component . execute ();
});
întoarce- te pe sine . valoare ;
};
}
Compozit . prototip = Obiect . creați ( Componentă . prototip );
Compozit . prototip . constructor = Compozit ;
// Aplicație
var bucătărie = new Composite ( 'Bucătărie' );
bucatarie . adăugați ( frunză nouă ( 'Secțiunea de sus' , 5200 ) ); bucatarie . adăugați ( frunză nouă ( 'Secțiunea dublă de sus' , 10000 ) ); bucatarie . adăugați ( frunză nouă ( „Secțiunea inferioară” , 4500 ) ); bucatarie . adăugați ( frunză nouă ( 'Secțiunea colțului de jos' , 7800 ) );
var echipament = compozit nou ( 'Echipament' );
echipamente . adaugă ( Leaf nou ( 'Sobă pe gaz' , 26400 ) ); echipamente . adăugați ( Leaf nou ( ' Frigider ' , 32300 ) ); echipamente . adauga ( Leaf nou ( 'Masina de spalat vase' , 21600 ) );
bucatarie . adauga ( echipament );
consola . log ( 'Total: ' + bucatarie . execute () + ' RUB' );
Exemplu rapid
Cod sursă rapid
articol de protocol {
var id : UInt32 { get }
var name : String { get }
func descriere () -> String
}
Butonul clasei : Item {
var id : UInt32 = arc4random ()
var name : String = "Buton"
func descriere () -> String {
return "ID: \( id ) | \( nume ) "
}
}
Etichetă de clasă : articol {
var id : UInt32 = arc4random ()
var name : String = „Etichetă”
func descriere () -> String {
return "ID: \( id ) | \( nume ) "
}
}
Vizualizare clasă : articol {
var componente : [ Item ] = []
var id : UInt32 = arc4random ()
var name : String = "Vizualizare"
func desctiption () -> String {
returnează componente . reduce ( "" , { " \( $0 ) \( $1 . descriere ()) " }) }
func add ( item : Item ) {
componente . adaugă ( articol )
}
func remove ( item : Item ) {
if let index = components . firstIndex ( unde : { $0 . id == item . id }) {
componente . eliminați ( la : index )
}
}
}
// Folosește Compozit
let button = Buton ()
print ( button.desctiption ( ) )
let view = View ()
view . adăugați ( element : Buton ())
vizualizare . adauga ( articol : Eticheta ())
print ( view.desctiption ( ) )
Link -uri