Learn PHP design patterns PHP implements composite pattern (composite)_php skills

1. Intention
Group objects into tree structures to represent part-whole hierarchies. Composite enables users to use single objects and composite objects consistently.
What Composite changes is the structure and composition of an object.
2. Main characters in synthesis mode
Abstract component (Component) role: Abstract role specifies an interface for the objects participating in the combination. Where appropriate, implement the default behavior of interfaces common to all classes. Declare an interface for accessing and managing subcomponents of Component
Leaf component (Leaf) role: represents the leaf node object in the combination, and the leaf node has no child nodes. Defines the behavior of primitive objects in a composition.
Tree component (Composite) role: Storage sub-components. Defines the behavior of those components that have subcomponents. Implement operations related to subcomponents in the Component interface.
Client: Manipulate the object of the combined component through the Component interface
3. Advantages and disadvantages of synthesis mode
Advantages of Composite mode
1. Simplify customer code
2. Make it easier to add new types of components

Disadvantages of the Composite pattern: making your design more general and easy to add components will also cause some problems, that is, it is difficult to limit the components in the combination
4. Applicable Scenarios of Synthesis Mode
1. You want to represent the part-whole hierarchy of the object
2. You want users to ignore the difference between composite objects and single objects, and users will use all objects in the composite structure uniformly.
5. Synthesis mode and other modes
Decorator pattern: Decorator pattern is often used together with Composite pattern. When decorators are used with composition, they usually have a common parent class. Therefore the decoration must support the Component interface with add, remove and getChild operations
Flyweight mode: Flyweight mode allows you to share components but no longer reference their parent widgets
Iterator mode: Itertor can be used to traverse Composite
Visitor pattern: Visitor localizes operations and behaviors that should be distributed in the Composite and Leaf classes.
6. Safe synthesis mode
Declare all methods used to manage subclass objects in the Composite class. This approach is safe. Because leaf type objects do not have methods to manage subclasses at all, if the client uses these methods on leaf type objects, the program will error at compile time. If the compilation fails, there will be no runtime errors
The disadvantage of this is that it is not transparent enough, because the leaf class and the composite class will have different interfaces.
7. Safe synthesis mode structure diagram

8. Safe synthesis mode PHP example

<&#63;php
/**
 * 抽象组件角色
 */
interface Component {
 
 /**
  * 返回自己的实例
  */
 public function getComposite();
 
 /**
  * 示例方法
  */
 public function operation();
}
 
/**
 * 树枝组件角色
 */
class Composite implements Component {
 private $_composites;
 
 public function __construct() {
  $this->_composites = array();
 }
 
 public function getComposite() {
  return $this;
 }
 
 /**
  * 示例方法，调用各个子对象的operation方法
  */
 public function operation() {
  echo 'Composite operation begin:<br />';
  foreach ($this->_composites as $composite) {
   $composite->operation();
  }
  echo 'Composite operation end:<br /><br />';
 }
 
 /**
  * 聚集管理方法 添加一个子对象
  * @param Component $component 子对象
  */
 public function add(Component $component) {
  $this->_composites[] = $component;
 }
 
 /**
  * 聚集管理方法 删除一个子对象
  * @param Component $component 子对象
  * @return boolean 删除是否成功
  */
 public function remove(Component $component) {
  foreach ($this->_composites as $key => $row) {
   if ($component == $row) {
    unset($this->_composites[$key]);
    return TRUE;
   }
  }
 
  return FALSE;
 }
 
 /**
  * 聚集管理方法 返回所有的子对象
  */
 public function getChild() {
  return $this->_composites;
 }
 
}
 
class Leaf implements Component {
 private $_name;
 
 public function __construct($name) {
  $this->_name = $name;
 }
 
 public function operation() {
  echo 'Leaf operation ', $this->_name, '<br />';
 }
 
 public function getComposite() {
  return null;
 }
}
 
 
/**
 * 客户端
 */
class Client {
 
 /**
  * Main program.
  */
 public static function main() {
  $leaf1 = new Leaf('first');
  $leaf2 = new Leaf('second');
 
  $composite = new Composite();
  $composite->add($leaf1);
  $composite->add($leaf2);
  $composite->operation();
 
  $composite->remove($leaf2);
  $composite->operation();
 }
 
}
 
Client::main();
&#63;>

synthesis mode. There are also some conceptual distinctions about the synthesis mode. I hope it will be helpful to everyone's learning.