Composite of design patterns (combination)

Composite definition :
Organize objects in a tree-shaped structure to achieve a "partial-overall" hierarchy, which makes the client consistent with the use of individual objects and composite objects.

Composite is easier to understand, think of composite should think of tree-shaped structure diagram. These objects in the composition have a common interface, and when a method of an object is called to execute, Composite will traverse (Iterator) The entire tree structure, looking for an object that also contains the method and implementing the call execution. Can be used to describe a move hundred.

So the composite mode is used in iterator mode, similar to the chain of responsibility mode.

Composite Benefits :
1. Making the client invocation simple, the client can consistently use a composite structure or a single object, and the user does not have to deal with a single object or the entire composition structure, which simplifies the client code.
2. It is easier to add object parts to the body. The client does not have to change the code because it joins a new object part.

How do I use composite?
First define an interface or abstract class, this is the design pattern common way, the other design patterns on the internal definition of the interface is not much, composite there is a rule, that is, in the interface to define a to access and manage the composite group of objects (or parts component).

The following code is defined as an abstract class, generally as far as possible with the interface interface

 Public Abstract classequipment{PrivateString name; //Internet Pricing 　　  Public Abstract DoubleNetprice (); //Discounted price 　　  Public Abstract DoubleDiscountprice (); //Adding part methods 　　  Public BooleanAdd (equipment Equipment) {return false; } //Remove Part method 　　  Public BooleanRemove (equipment Equipment) {return false; } //note here, here is a part method for accessing the Assembly class.  　　  PublicIterator iter () {return NULL; }  PublicEquipment (FinalString name) { This. name=name;}}

Abstract class equipment is the definition of component, which represents the objects of the composition class, and defines several common methods in equipment.

 public  class  Disk extends   equipment{ public　　 Disk (String name) {super   //  define disk network price is 1  public  double  netprice () {　　return  1.;}  //  defines a disk discount price of 0.5 fold.  public  double  Discountprice () { Span style= "COLOR: #0000ff" >return . 5;}}  

Disk is an object in a group, or a part, which is a separate element (Primitive).
Another possibility is that a component is also a combination, that is, there is a ' son ' under this part, which is usually the case in the tree structure, which should be more easily understood. Now we need to define this composition first:

Abstract classCompositeequipmentextendsequipment{Private intI=0; //define a vector to hold ' son ' 　　 PrivateLsit equipment=NewArrayList ();  PublicCompositeequipment (String name) {Super(name);}  Public BooleanAdd (equipment equipment) { This. Equipment.add (equipment); return true; } Public DoubleNetprice () {DoubleNetprice=0.; Iterator ITER=Equipment.iterator ();  for(Iter.hasnext ()) Netprice+=( (equipment) iter.next ()). Netprice (); returnNetprice; } Public DoubleDiscountprice () {DoubleDiscountprice=0.; Iterator ITER=Equipment.iterator ();  for(Iter.hasnext ()) Discountprice+=( (equipment) iter.next ()). Discountprice (); returnDiscountprice; }//Note here that this provides a way to access parts of your own assembly. //The reason that disk is not there is because disk is a separate (Primitive) element. 　　  PublicIterator iter () {returnEquipment.iterator (); {//Overloaded Iterator Method 　　   Public BooleanHasnext () {returni<equipment.size ();} //Overloaded Iterator Method 　　   PublicObject Next () {if(Hasnext ())returnEquipment.elementat (i++); Else  　　 　　 　  Throw Newnosuchelementexception (); }}

The above compositeequipment inherits the equipment, and also provides an external access method for the objects inside, overloading the iterator,iterator is an interface of Java collection, is the implementation of the iterator pattern.

Let's take a look at Compositeequipment's two specific classes: Tray box chassis and box cabinet, the box can put a lot of things, such as the backplane, power box, hard disk box, etc., the box can put some small devices, such as hard disk floppy drive. Undoubtedly these two belong to the combination nature.

 Public classChassisextendscompositeequipment{ PublicChassis (String name) {Super(name);}  Public DoubleNetprice () {return1.+Super. Netprice ();}  Public DoubleDiscountprice () {return.5+Super. Discountprice ();}}  Public classCabinetextendscompositeequipment{ PublicCabinet (String name) {Super(name);}  Public DoubleNetprice () {return1.+Super. Netprice ();}  Public DoubleDiscountprice () {return.5+Super. Discountprice ();}}

At this point we have completed the architecture of the entire composite model.

We can look at the client call Composote code:

Cabinet cabinet=New Cabinet ("Tower"); Chassis Chassis=new Chassis ("PC Chassis"); // load the PC chassis into the tower (pack the tray into the box) Cabinet.add (chassis); // install a 10GB hard drive into the PC Chassis (install the hard drive into the disk box)chassis.add ("Ten GB"); // Call the Netprice () method; System.out.println ("netprice=" +Cabinet.netprice ()); System.out.println ("discountprice=" +cabinet.discountprice ());

The method called above Netprice () or Discountprice (), actually composite uses iterator to traverse the entire tree structure, looking for objects that also contain this method and implementing the call execution.

Composite is a clever model of wisdom, and in practice, if you encounter a tree structure, we can try to use this pattern.

Take the forum as an example, there are many posts in a version (message), these posts have the original paste, there is a response to the original sticker, is a typical tree structure, then of course you can use the composite mode, then we enter the jive to see how it is implemented.

Jive Anatomy
In Jive, Forumthread is the Forummessages container container (composition). That is, Forumthread is similar to the compositeequipment in our example above. Its relationship with messages

[Thread] | - [message] | - [message] | - [message] | - [message] | -[Message]

We see the following code in Forumthread:

 Public Interface public void   throws public void throws　　 　　   public Iterator messages (); .... }

Similar to Compositeequipment, provides methods for accessing parts of the body in its own composition: increased delete traversal.

In combination with my other models of jive analysis, we have basically understood the framework of the Jive Forum system, if you do not understand the design pattern, and directly to see Jive Source code, you certainly can not read.

Transferred from: http://www.jdon.com Banqiao

Composite (combination) of design patterns (RPM)