java设计模式7：Composite

最新推荐文章于 2025-08-10 08:32:47 发布

原创最新推荐文章于 2025-08-10 08:32:47 发布 · 865 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#设计模式 #java #components #vector #class #import

本文介绍了组合模式的两种形式：安全式和透明式。安全式模式通过让树枝构件定义管理子对象的方法来防止对树叶构件的误操作；透明式模式则要求所有构件都遵循相同的接口。通过图形绘制的例子展示了两种模式的应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

安全式的组合模式

涉及到三个角色：
1、抽象构件（Component)：这是一个抽象角色，它给参加组合的对象定义出公共的接口及其默认行为，可以用来管理所有的子对象。组合对象通常把它所包含的子对象当做类型为Component的对象。在安全式的合成模式里，构件角色并不定义出管理子对象的方法，这一定义由树枝构件对象给出。
2、树叶构件（Leaf)：树叶对象是没有下级子对象的对象，定义出参加组合的原始对象的行为。
3、树枝构件（Composite):代表参加组合的有下级子对象的对象。树枝构件类给出所有的管理子对象的方法，如add(),remove(),以及components()的声明。

package com.javapatterns.composite;

/**
* @author luhx
*/
public interface Component {

Composite getComposite();

void sampleOperation();
}

package com.javapatterns.composite;

import java.util.Vector;
import java.util.Enumeration;

public class Composite implements Component
{
    public Composite getComposite()
    {
        return this;
    }

    public void sampleOperation()
    {
        java.util.Enumeration enumeration = components();
        while (enumeration.hasMoreElements())
        {
            ((Component)enumeration.nextElement()).sampleOperation();
        }
    }

    public void add(Component component)
    {
        componentVector.addElement(component);
    }

    public void remove(Component component)
    {
        componentVector.removeElement(component);
    }

    public Enumeration components()
    {
        return componentVector.elements();
    }

    /**
     * @associates   <{Component}>
     * @link   aggregation
     * @supplierCardinality   0..
     * @uml.property name="componentVector"
     * @uml.associationEnd multiplicity="(0 -1)" inverse="composite:com.javapatterns.composite.Component"
     */
    private Vector componentVector = new java.util.Vector();
}

package com.javapatterns.composite;

public class Leaf implements Component {
    public Composite getComposite(){
        // Write your code here
        return null;
    }

    public void sampleOperation(){
        // Write your code here
    }
}

可以看出，树枝构件类给出了add(),remove()以及components()等方法的声明和实现，而树叶构件类则没有给出这些方法的声明或实现。由于这个特点，客户端应用程序不可能错误地调用树叶构件的聚集方法，因为树叶构件没有这些方法，调用会导致编译出错。

透明式的组合模式的结构

与安全模式的组合模式不同的是，透明式的组合模式要求所有的具体构件类，不论树枝构件还是树叶构件，均符合一个固定的接口。透明式的组合模式的示意性类图如下所示：

涉及到三个角色：

1、抽象构件(Component)：这是一个抽象角色，它给参加组合的对象规定一个接口，规范共有的接口及默认行为。这个接口可以用来管理所有的子对象，要提供一个接口以规范取得和管理下层组件的接口中，包括add(),remove()以及getChild()之类的方法。
2、树叶构件（Leaf)：代表参加组合的树叶对象，定义出参加组合的原始对象的行为。树叶类会给出add(),remove(),以及getChild()之类的用来管理子类对象的方法的平庸实现。
3、树枝构件（Composite)：代表参加组合的有子对象的对象，定义出这样的对象的行为

package com.javapatterns.composite.transparent;

import java.util.Enumeration;
/**
* @author luhx
*/
public interface Component
{
void sampleOperation();

    /**
     * @uml.property name="composite"
     * @uml.associationEnd inverse="componentVector:com.javapatterns.composite.transparent.Composite"
     */
    Composite getComposite();

void add(Component component);

void remove(Component component);

Enumeration components();
}

package com.javapatterns.composite.transparent;

import java.util.Vector;
import java.util.Enumeration;

public class Composite implements Component
{
    public Composite getComposite()
    {
        return this;
    }

    public void add(Component component)
    {
        componentVector.addElement(component);
    }

    public void remove(Component component)
    {
        componentVector.removeElement(component);
    }

    public Enumeration components()
    {
        return componentVector.elements();
    }

    /**
     * @associates   <{Component}>
     * @link   aggregation
     * @supplierCardinality   0..
     * @uml.property name="componentVector"
     * @uml.associationEnd multiplicity="(0 -1)" inverse="composite:com.javapatterns.composite.transparent.Component"
     */
    private Vector componentVector = new java.util.Vector();
}

package com.javapatterns.composite.transparent;

import java.util.Enumeration;
import java.util.Vector;

public class Leaf implements Component
{
    public void sampleOperation()
    {
        // Write your code here
    }

    public void add(Component component)
    {
        componentVector.addElement(component);
    }

    public void remove(Component component)
    {
        componentVector.removeElement(component);
    }

    public Composite getComposite()
    {
        // Write your code here
        return null;
    }

    public Enumeration components()
    {
        // Write your code here
        return null;
    }

    /**
     * @associates   <{Component}>
     * @link   aggregation
     * @supplierCardinality   0..
     * @uml.property name="componentVector"
     * @uml.associationEnd multiplicity="(0 -1)" elementType="com.javapatterns.composite.transparent.Component"
     */
    private Vector componentVector = new java.util.Vector();
}

一个例子（安全式组合模式）：