Java design pattern composition pattern example analysis

1.Basic introduction

1) Composite Pattern, also called Partial Whole Pattern, creates a tree structure of object groups and combines objects into a tree structure to represent "whole- The hierarchical relationship of "part"

2) The combination mode combines objects according to the tree structure to represent the part and the whole hierarchy

3) This type of design pattern belongs to the structural pattern

4) The combination mode enables users to have consistent access to single objects and combined objects, that is: combination allows customers to process individual objects and combined objects in a consistent manner

2. Structure

The combination mode mainly includes three roles:

• Abstract root node (Component): defines the common methods and attributes of objects at all levels of the system, and can predefine some default behaviors and attributes

• Branch node (Composite): Define the behavior of branch nodes, store child nodes, and combine branch nodes and leaf nodes to form a tree structure

• Leaf node (Leaf): Leaf node object, with no branches below it, is the smallest unit for system level traversal

3. Problems solved by the combination mode

1) The combination pattern solves this problem. When the object we want to process can generate a tree structure, and we want to operate on the nodes and leaves on the tree, it can provide a consistent way, regardless of whether it is a node or a leaf.

2) Corresponding schematic diagram

#4. Combination model to solve school department display

1) Application example requirements

Write a program to display the departmental structure of a school: the demand is as follows. To display the school’s departmental composition on one page, a school has multiple colleges, and a college has multiple departments

2) Idea analysis and illustration (class diagram)

##3) Code implementation

Component composite object declaration interface

package com.zte;
public abstract class OrganizationComponent {
    private String name;// 名字
    private String des;// 说明
    public String getName() {
        return name;
    }
    public String getDes() {
        return des;
    }
    protected void add(OrganizationComponent organizationComponent) {
        // 默认实现
        throw new UnsupportedOperationException();
    }
    protected void remove(OrganizationComponent organizationComponent) {
        // 默认实现
        throw new UnsupportedOperationException();
    }
    // 构造器
    public OrganizationComponent(String name, String des) {
        this.name = name;
        this.des = des;
    }
    // 方法print，抽象方法
    protected abstract void print();
}

Composite non-leaf node

package com.zte;
import java.util.ArrayList;
import java.util.List;
// University 就是 Composite，可以管理College
public class University extends OrganizationComponent {
    List<OrganizationComponent> organizationComponentList = new ArrayList<>();
    // 构造器
    public University(String name, String des) {
        super(name, des);
    }
    //重写add
    @Override
    protected void add(OrganizationComponent organizationComponent) {
        organizationComponentList.add(organizationComponent);
    }
    // 重写remove
    @Override
    protected void remove(OrganizationComponent organizationComponent) {
        organizationComponent.remove(organizationComponent);
    }
    @Override
    protected void print() {
        System.out.println("==========" + getName() + "=========");
        for (OrganizationComponent organizationComponent : organizationComponentList) {
            organizationComponent.print();
        }
    }
    @Override
    public String getName() {
        return super.getName();
    }
    @Override
    public String getDes() {
        return super.getDes();
    }
}

Composite non-leaf node

package com.zte;
import java.util.ArrayList;
import java.util.List;
public class College extends OrganizationComponent {
    // list中存放department
    List<OrganizationComponent> organizationComponentList = new ArrayList<>();
    public College(String name, String des) {
        super(name, des);
    }
    //重写add
    @Override
    protected void add(OrganizationComponent organizationComponent) {
        organizationComponentList.add(organizationComponent);
    }
    // 重写remove
    @Override
    protected void remove(OrganizationComponent organizationComponent) {
        organizationComponent.remove(organizationComponent);
    }
    @Override
    protected void print() {
        System.out.println("==========" + getName() + "=========");
        for (OrganizationComponent organizationComponent : organizationComponentList) {
            organizationComponent.print();
        }
    }
    @Override
    public String getName() {
        return super.getName();
    }
    @Override
    public String getDes() {
        return super.getDes();
    }
}

Leaf leaf node

package com.zte;
public class Department extends OrganizationComponent {
    public Department(String name, String des) {
        super(name, des);
    }
    // add和remove方法就不需要再写了
    @Override
    protected void print() {
        System.out.println("===========" + getName() + "=========");
    }
    @Override
    public String getName() {
        return super.getName();
    }
    @Override
    public String getDes() {
        return super.getDes();
    }
}

package com.zte;
public class Client {
    public static void main(String[] args) {
        // 创建大学
        OrganizationComponent university = new University("清华大学", "中国最好的大学");
        // 创建学院
        OrganizationComponent college1 = new College("计算机学院", "计算机学院");
        OrganizationComponent college2 = new College("信息工程学院", "信息工程学院");
        // 创建各个学院下面的系
        college1.add(new Department("软件工程", "软件工程"));
        college1.add(new Department("网络工程", "网络工程"));
        college1.add(new Department("计算机科学与技术", "老牌专业"));
        college2.add(new Department("通信工程", "通信工程"));
        college2.add(new Department("信息工程", "信息工程"));
        // 将学院添加到学校中
        university.add(college1);
        university.add(college2);
        // 打印大学底下的所有院系
        university.print();
        // 打印学院底下的所有系
        college1.print();
    }
}

5. Precautions and details of the combination mode

1) Simplify the client operation, the client The end only needs to face consistent objects without considering the problem of the whole part or node leaves

2) It has strong scalability. When we need to modify the combined object, we only need to adjust the internal hierarchical relationship , the client does not need to make any changes

3) It is convenient to create complex hierarchical structures. The client does not need to pay attention to the composition details in the combination, and it is easy to add nodes or leaves to create complex tree structures

4) When you need to traverse the organization structure, or the object being processed has a tree structure, it is very suitable to use the combination mode

5) Requires high abstraction, if there are many differences between nodes and leaves, For example, many methods and properties are different, so it is not suitable to use the combination mode

The above is the detailed content of Java design pattern composition pattern example analysis. For more information, please follow other related articles on the PHP Chinese website!