Composite比较容易理解，想到Composite就应该想到树形结构图。组合体内这些对象都有共同接口,当组合体一个对象的方法被调用执行时，Composite将遍历(Iterator)整个树形结构,寻找同样包含这个方法的对象并实现调用执行。可以用牵一动百来形容。

所以Composite模式使用到Iterator模式，和Chain of Responsibility模式类似。

三、Composite好处

1.使客户端调用简单，客户端可以一致的使用组合结构或其中单个对象，用户就不必关系自己处理的是单个对象还是整个组合结构，这就简化了客户端代码。
2.更容易在组合体内加入对象部件. 客户端不必因为加入了新的对象部件而更改代码。

四、如何使用Composite

首先定义一个接口或抽象类，这是设计模式通用方式了，其他设计模式对接口内部定义限制不多，Composite却有个规定，那就是要在接口内部定义一个用于访问和管理Composite组合体的对象们（或称部件Component）.

    ---- 以上内容摘自Jdon网站的《Gof 23种设计模式》系列文章

五、Composite模式的分析

·Composite模式的结构：
基类/接口(构件抽象)
    |
    |--- 原子构件(extends 基类 / implements 接口)
    |
    |--- 组合构件(extends 基类 / implements 接口)
               |--- 原子构件1
               |--- 原子构件2
               |--- 组合构件3
　　　　　　         |--- 原子构件3-1
                        |--- 原子构件3-2

·Composite模式的特点：
   ·Composite模式一般都有一个抽象类或接口来表示最基本的构件。
   ·Composite模式一般都由两类对象构成：表示单个元素的对象(Primitive)和表示多个元素组合的对象(Composite)
   ·Composite模式下Primitive和Composite对象都继承或实现上层接口或父类
   ·Composite模式下每个构件都含有三个基础方法：add(构件)、remove(构件)、iterator()
   ·Composite对象含有一个用来保存其下所有基础元素的的集合，例如：Vector，ArrayList，HashMap
   ·Composite对象的方法被调用时一般都会引起其下所有基础元素相同方法的调用，即递归调用。

·Composite模式中Primitive对象和Composite对象的方法区别：
   ·add(构件)：如果是基础对象，则此方法直接返回false，如果是组合对象，则先添加新构件然后返回true
   ·remove(构件)：如果是基础对象，则此方法直接返回false，如果是组合对象，则先删除构件然后返回true
   ·iterator()：如果是基础对象，则此方法直接返回null，如果是组合对象，则返回一个包含所有对象的集合

·客户端调用Composite模式的代码示例：
   ·创建一个原子构件对象
   ·创建一个组合构件对象
   ·调用组合构件对象的add/remove方法添加/删除对象
   ·调用组合够对象的iteratore方法迭代显示对象
本文摘自：http://www.blogjava.net/pengpenglin/archive/2008/01/21/176675.html
续：

一个二叉树的例子：
1.Component 是抽象组件
Tree 和Leaf 继承Component

private String name; //树或叶子的名称
addChild(Component leftChild,Component rightChild);
//给一个树上加上一个左孩子，一个右孩子
getName(){return name;}
getTreeInfo(){} //得到树或叶子的详细信息
getLength(); //得到树的高度

2.Tree 二叉树，一个左孩子，一个右孩子

3.Leaf 是叶子节点
4.Test 是测试节点

/** Component.java **************/
package binarytree;

public abstract class Component {
 private String name;

 public abstract Component addChild(Component leftChild, Component rightChild);

 public String getName() {
  return name;
 }

 public void getTreeInfo() {
 }

 public abstract int getLength();
}


/** Leaf.java **************/
package binarytree;

public class Leaf extends Component {
 private String name;

 private Component leaf = null;

 public Leaf(String name) {
  this.name = name;
 }

 public Component addChild(Component leftChild, Component rightChild) {
  return this;
 }

 public String getName() {
  return name;
 }

 public int getLength() {
  return 1;
 }

 public static void main(String[] args) {
 }
}

/** Tree.java **************/
package binarytree;

public class Tree extends Component {
 private String name;

 private Component leftChild;

 private Component rightChild;

 public Tree(String name, Component leftChild, Component rightChild) {
  this.name = name;
  this.leftChild = leftChild;
  this.rightChild = rightChild;
 }

 public Tree(String name) {
  this.name = name;
  this.leftChild = null;
  this.rightChild = null;
 }

 public Component addChild(Component leftChild, Component rightChild) {
  this.leftChild = leftChild;
  this.rightChild = rightChild;
  return this;
 }

 public String getName() {
  return name;
 }

 public void getTreeInfo()
 // 得到树或叶子的详细信息
 // 先打印自己的名字，再遍例左孩子，再遍例右孩子
 // 如果左孩子或右孩子是树，递归调用
 {
  System.out.println(" this trees name is " + getName());
  if (this.leftChild instanceof Leaf) {
   System.out.println(getName() + "s left child is "
     + this.leftChild.getName() + ",it is a Leaf");
  }
  if (this.leftChild instanceof Tree) {
   System.out.println(getName() + "s left child is "
     + this.leftChild.getName() + ",it is a Tree");
   this.leftChild.getTreeInfo();
  }
  if (this.leftChild == null) {
   System.out.println(getName() + "s left child is a null");
  }
  if (this.rightChild instanceof Leaf) {
   System.out.println(getName() + "s right child is "
     + this.rightChild.getName() + ",it is a Leaf");
  }
  if (this.rightChild instanceof Tree) {
   System.out.println(getName() + "s right child is "
     + this.rightChild.getName() + ",it is a Tree");
   this.rightChild.getTreeInfo();
  }
  if (this.rightChild == null) {
   System.out.println(getName() + "s right child is a null");
  }
  // System.out.println(getName()+"s 高度 是 "+getLength());
 }

 public int getLength() {
  // 比较左孩子或右孩子的高度，谁大，+1 返回
  // 空孩子的处理
  if (this.leftChild == null) {
   if (this.rightChild == null)
    return 1;
   else
    return this.rightChild.getLength() + 1;
  } else {
   if (this.rightChild == null) {
    return this.leftChild.getLength() + 1;
   } else {
    if ((this.leftChild.getLength()) >= (this.rightChild
      .getLength()))
     return this.leftChild.getLength() + 1;
    else
     return this.rightChild.getLength() + 1;
   }
  }
 }

 public static void main(String[] args) {
 }
}

/** Test.java 测试类 **************/
package binarytree;

public class Test {

 public Test() {
 }

 public static void main(String[] args) {
  Component tree = new Tree("luopeng");
  Component left_child = new Leaf("luopeng1");
  Component right_child = new Leaf("luopeng2");
  tree = tree.addChild(left_child, right_child);
  // tree=tree.addRightChild(right_child);
  tree.getTreeInfo();
  Component tree1 = new Tree("luopeng2");
  tree1.addChild(tree, left_child);
  tree1.getTreeInfo();
  Component tree2 = new Tree("luopeng3");
  tree2.addChild(tree, null);
  tree2.getTreeInfo();
  Component tree4 = new Tree("luopeng4");
  tree4.addChild(null, tree);
  tree4.getTreeInfo();
  System.out.println(tree4.getName() + "的高度是 " + tree4.getLength());
 }
}

一、 引言
　　迭代这个名词对于熟悉Java的人来说绝对不陌生。我们常常使用JDK提供的迭代接口进行java collection的遍历：
Iterator it = list.iterator();
while(it.hasNext()){
　//using “it.next();”do some businesss logic
}
而这就是关于迭代器模式应用很好的例子。

　　二、 定义与结构

　　迭代器（Iterator）模式，又叫做游标（Cursor）模式。GOF给出的定义为：提供一种方法访问一个容器（container）对象中各个元素，而又不需暴露该对象的内部细节。

　　从定义可见，迭代器模式是为容器而生。很明显，对容器对象的访问必然涉及到遍历算法。你可以一股脑的将遍历方法塞到容器对象中去；或者根本不去提供什么遍历算法，让使用容器的人自己去实现去吧。这两种情况好像都能够解决问题。

　　然而在前一种情况，容器承受了过多的功能，它不仅要负责自己“容器”内的元素维护（添加、删除等等），而且还要提供遍历自身的接口；而且由于遍历状态保存的问题，不能对同一个容器对象同时进行多个遍历。第二种方式倒是省事，却又将容器的内部细节暴露无遗。

　　而迭代器模式的出现，很好的解决了上面两种情况的弊端。先来看下迭代器模式的真面目吧。

　　迭代器模式由以下角色组成：

　　1) 迭代器角色（Iterator）：迭代器角色负责定义访问和遍历元素的接口。

　　2) 具体迭代器角色（Concrete Iterator）：具体迭代器角色要实现迭代器接口，并要记录遍历中的当前位置。

　　3) 容器角色（Container）：容器角色负责提供创建具体迭代器角色的接口。

　　4) 具体容器角色（Concrete Container）：具体容器角色实现创建具体迭代器角色的接口——这个具体迭代器角色于该容器的结构相关。

　　迭代器模式的类图如下：

public interface Iterator {
　boolean hasNext();
　Object next();
　void remove();
}

//容器角色，这里以List为例。它也仅仅是一个接口，就不罗列出来了
//具体容器角色，便是实现了List接口的ArrayList等类。为了突出重点这里指罗列和迭代器相关的内容
//具体迭代器角色，它是以内部类的形式出来的。AbstractList是为了将各个具体容器角色的公共部分提取出来而存在的。

public abstract class AbstractList extends AbstractCollection implements List {
……
//这个便是负责创建具体迭代器角色的工厂方法
public Iterator iterator() {
　return new Itr();
}

//作为内部类的具体迭代器角色

private class Itr implements Iterator {
　int cursor = 0;
　int lastRet = -1;
　int expectedModCount = modCount;

　public boolean hasNext() {
　　return cursor != size();
　}

　public Object next() {
　　checkForComodification();
　　try {
　　　Object next = get(cursor);
　　　lastRet = cursor++;
　　　return next;
　　} catch(IndexOutOfBoundsException e) {
　　　checkForComodification();
　　　throw new NoSuchElementException();
　　}
　}

　public void remove() {
　　if (lastRet == -1)
　　　throw new IllegalStateException();
　　　checkForComodification();

　　try {
　　　AbstractList.this.remove(lastRet);
　　　if (lastRet < cursor)
　　　　cursor--;
　　　lastRet = -1;
　　　expectedModCount = modCount;
　　} catch(IndexOutOfBoundsException e) {
　　　throw new ConcurrentModificationException();
　　}
　}

　final void checkForComodification() {
　　if (modCount != expectedModCount)
　　　throw new ConcurrentModificationException();
　}
}
至于迭代器模式的使用。正如引言中所列那样，客户程序要先得到具体容器角色，然后再通过具体容器角色得到具体迭代器角色。这样便可以使用具体迭代器角色来遍历容器了……

　　四、 实现自己的迭代器

　　在实现自己的迭代器的时候，一般要操作的容器有支持的接口才可以。而且我们还要注意以下问题：

　　在迭代器遍历的过程中，通过该迭代器进行容器元素的增减操作是否安全呢？

　　在容器中存在复合对象的情况，迭代器怎样才能支持深层遍历和多种遍历呢？

　　以上两个问题对于不同结构的容器角色，各不相同，值得考虑。

　　五、 适用情况

　　由上面的讲述，我们可以看出迭代器模式给容器的应用带来以下好处：

　　1) 支持以不同的方式遍历一个容器角色。根据实现方式的不同，效果上会有差别。

　　2) 简化了容器的接口。但是在java Collection中为了提高可扩展性，容器还是提供了遍历的接口。

　　3) 对同一个容器对象，可以同时进行多个遍历。因为遍历状态是保存在每一个迭代器对象中的。

　　由此也能得出迭代器模式的适用范围：

　　1) 访问一个容器对象的内容而无需暴露它的内部表示。

　　2) 支持对容器对象的多种遍历。

　　3) 为遍历不同的容器结构提供一个统一的接口（多态迭代）。

实例：

public class IteratorDemo {
 private List<String> strList;

 public IteratorDemo() {
  strList = new ArrayList<String>();
 }

 public void add(String item) {
  strList.add(item);
 }

 public String remove(int index) {
  String item = strList.get(index);
  strList.remove(index);
  return item;
 }

 public Iterator<String> iterator() {
  return new Iterator<String>() {
   // 游标
   private int cursor = 0;

   public boolean hasNext() {
    return cursor < strList.size();
   }

   public String next() {
    return strList.get(cursor++);
   }

   public void remove() {

   }

  };
 }

 public static void main(String[] args) {
  IteratorDemo demo = new IteratorDemo();
  demo.add("1");
  demo.add("2");
  demo.add("3");
  demo.add("4");

  Iterator<String> iterator = demo.iterator();
  while (iterator.hasNext()) {
   System.out.println(iterator.next());
  }
 }
}

转自2004年6期《CSDN开发高手》

• 目标(Target)角色：这就是所期待得到的接口。
  

• 源(Adaptee)角色：现有需要适配的接口。
  
• 适配器(Adapter)角色：适配器类是本模式的核心。适配器把源接口转换成目标接口。显然这一角色不可以是接口，而必须是具体类。

/**
 * 定义Client使用的与特定领域相关的接口
 */
public interface Target {
    void sampleOperation1();
    void sampleOperation2();
}
/**
 * 定义一个已经存在的接口，这个接口需要适配
 */
public class Adaptee {
    public void sampleOperation1() {
        // ......
    }
}
/**
 * 对Adaptee与Target接口进行适配
 */
public class Adapter extends Adaptee implements Target {
    public void sampleOperation2() {
        // ......
    }
}

二、对象适配器
    与类的适配器模式一样，对象适配器模式把适配的类的API转换成为目标类的API，与类的适配器模式不同的是，对象的适配器模式不是使用继承关系连接到Adaptee类，而是使用委派关系连接到Adaptee类。示意代码如下：
/**
 * 定义Client使用的与特定领域相关的接口
 */
public interface Target {
    void sampleOperation1();
    void sampleOperation2();
}
/**
 * 定义一个已经存在的接口，这个接口需要适配
 */
public class Adaptee {
    public void sampleOperation1() {
        // ......
    }
}
/**
 * 对Adaptee与Target接口进行适配
 */
public class Adapter implements Target {
    private Adaptee adaptee;
    public Adapter(Adaptee adaptee) {
        super();
        this.adaptee = adaptee;
    }
    public void sampleOperation1() {
        adaptee.sampleOperation1(); // 看点
    }
    public void sampleOperation2() {
        // ......
    }
}

类适配器模式和对象适配器模式的异同：Target接口和Adaptee类都相同，不同的是类适配器的Adapter继承Adaptee实现Target，对象适配器的Adapter实现Target聚集Adaptee。

适配器模式的用意是将接口不同而功能相同或者相近的两个接口加以转换。

代理模式的作用是：为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，一个客户不想或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。

代理模式一般涉及到的角色有：

抽象角色 ：声明真实对象和代理对象的共同接口；

代理角色 ：代理对象角色内部含有对真实对象的引用，从而可以操作真实对象，同时代理对象提供与真实对象相同的接口以便在任何时刻都能代替真实对象。同时，代理对象可以在执行真实对象操作时，附加其他的操作，相当于对真实对象进行封装。

真实角色 ：代理角色所代表的真实对象，是我们最终要引用的对象。 ( 参见文献 1)

以下以《 Java 与模式》中的示例为例：

抽象角色：

abstract public class Subject

{

    abstract public void request();

}

真实角色：实现了 Subject 的 request() 方法。

public class RealSubject extends Subject

{

       public RealSubject()

       {

       }

       public void request()

       {

              System.out.println("From real subject.");

       }

}

代理角色：

public class ProxySubject extends Subject

{

    private RealSubject realSubject;  // 以真实角色作为代理角色的属性

       public ProxySubject()

       {

       }

       public void request()  // 该方法封装了真实对象的 request 方法

       {

        preRequest(); 

              if( realSubject == null )

        {

                     realSubject = new RealSubject();

              }

        realSubject.request();  // 此处执行真实对象的 request 方法

        postRequest();

       }

    private void preRequest()

    {

        //something you want to do before requesting

    }

    private void postRequest()

    {

        //something you want to do after requesting

    }

}

客户端调用：

Subject sub=new ProxySubject();

Sub.request();

       由以上代码可以看出，客户实际需要调用的是 RealSubject 类的 request() 方法，现在用 ProxySubject 来代理 RealSubject 类，同样达到目的，同时还封装了其他方法 (preRequest(),postRequest()) ，可以处理一些其他问题。

       另外，如果要按照上述的方法使用代理模式，那么真实角色必须是事先已经存在的，并将其作为代理对象的内部属性。但是实际使用时，一个真实角色必须对应一个代理角色，如果大量使用会导致类的急剧膨胀；此外，如果事先并不知道真实角色，该如何使用代理呢？这个问题可以通过 Java 的动态代理类来解决。

2. 动态代理类

       Java 动态代理类位于 Java.lang.reflect 包下，一般主要涉及到以下两个类：

(1). Interface InvocationHandler ：该接口中仅定义了一个方法 Object ： invoke(Object obj,Method method, Object[] args) 。在实际使用时，第一个参数 obj 一般是指代理类， method 是被代理的方法，如上例中的 request() ， args 为该方法的参数数组。这个抽象方法在代理类中动态实现。

(2).Proxy ：该类即为动态代理类，作用类似于上例中的 ProxySubject ，其中主要包含以下内容：

Protected Proxy(InvocationHandler h) ：构造函数，估计用于给内部的 h 赋值。

Static Class getProxyClass (ClassLoader loader, Class[] interfaces) ：获得一个代理类，其中 loader 是类装载器， interfaces 是真实类所拥有的全部接口的数组。

Static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h) ：返回代理类的一个实例，返回后的代理类可以当作被代理类使用 ( 可使用被代理类的在 Subject 接口中声明过的方法 ) 。

       所谓 Dynamic Proxy 是这样一种 class ：它是在运行时生成的 class ，在生成它时你必须提供一组 interface 给它，然后该 class 就宣称它实现了这些 interface 。你当然可以把该 class 的实例当作这些 interface 中的任何一个来用。当然啦，这个 Dynamic Proxy 其实就是一个 Proxy ，它不会替你作实质性的工作，在生成它的实例时你必须提供一个 handler ，由它接管实际的工作。 ( 参见文献 3)

    在使用动态代理类时，我们必须实现 InvocationHandler 接口，以第一节中的示例为例：

抽象角色 ( 之前是抽象类，此处应改为接口 ) ：

public interface Subject

{

    abstract public void request();

}

具体角色 RealSubject ：同上；

代理角色：

import java.lang.reflect.Method;

import java.lang.reflect.InvocationHandler;

public class DynamicSubject implements InvocationHandler {

  private Object sub;

  public DynamicSubject() {

  }

  public DynamicSubject(Object obj) {

    sub = obj;

  }

  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

    System.out.println("before calling " + method);

    method.invoke(sub,args);

    System.out.println("after calling " + method);

    return null;

  }

}

       该代理类的内部属性为 Object 类，实际使用时通过该类的构造函数 DynamicSubject(Object obj) 对其赋值；此外，在该类还实现了 invoke 方法，该方法中的

method.invoke(sub,args);

其实就是调用被代理对象的将要被执行的方法，方法参数 sub 是实际的被代理对象， args 为执行被代理对象相应操作所需的参数。通过动态代理类，我们可以在调用之前或之后执行一些相关操作。

客户端 ：

import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Proxy;

import java.lang.reflect.Constructor;

import java.lang.reflect.Method;

public class Client

{

    static public void main(String[] args) throws Throwable

       {

      RealSubject rs = new RealSubject();  // 在这里指定被代理类

      InvocationHandler ds = new DynamicSubject(rs);  // 初始化代理类

         Class cls = rs.getClass();

      // 以下是分解步骤

      /*

      Class c = Proxy.getProxyClass(cls.getClassLoader(),cls.getInterfaces()) ;

      Constructor ct=c.getConstructor(new Class[]{InvocationHandler.class});

      Subject subject =(Subject) ct.newInstance(new Object[]{ds});

     */

     // 以下是一次性生成

      Subject subject = (Subject) Proxy.newProxyInstance(cls.getClassLoader(),

                                 cls.getInterfaces(),ds );

      subject.request();

}

       通过这种方式，被代理的对象 (RealSubject) 可以在运行时动态改变，需要控制的接口 (Subject 接口 ) 可以在运行时改变，控制的方式 (DynamicSubject 类 ) 也可以动态改变，从而实现了非常灵活的动态代理关系 ( 参见文献 2) 。

　　private Singleton(){}

　　//在自己内部定义自己一个实例，是不是很奇怪？
　　//注意这是private 只供内部调用

　　private static Singleton instance = new Singleton();

　　//这里提供了一个供外部访问本class的静态方法，可以直接访问　　
　　public static Singleton getInstance() {
　　　　return instance; 　　
　　 }
}

2.懒汉式单例类
public class Singleton2 {
    //私有的默认构造子
    private Singleton2() {}
    
    //注意，这里没有final    
    private static Singleton2 single;
    
    //只实例化一次
    static{
        single = new Singleton2();
    }
    
    //静态工厂方法 
    public synchronized  static Singleton2 getInstance() {
         if (single == null) {  
             single = new Singleton2();
         }  
        return single;
    }
}
        上面给出懒汉式单例类实现里对静态工厂方法使用了同步化，以处理多线程环境。有些设计师在这里建议使用所谓的"双重检查成例".必须指出的是，"双重检查成例"不可以在Java 语言中使用。不十分熟悉的读者，可以看看后面给出的小节。 同样，由于构造子是私有的，因此，此类不能被继承。饿汉式单例类在自己被加载时就将自己实例化。即便加载器是静态的，在饿汉式单例类被加载时仍会将自己实例化。单从资源利用效率角度来讲，这个比懒汉式单例类稍差些。从速度和反应时间角度来讲，则比懒汉式单例类稍好些。然而，懒汉式单例类在实例化时，必须处理好在多个线程同时首次引用此类时的访问限制问题，特别是当单例类作为资源控制器，在实例化时必然涉及资源初始化，而资源初始化很有可能耗费时间。这意味着出现多线程同时首次引用此类的机率变得较大。

3.单例模式 -- 双重检查锁机制
public class DoubleLockSingleton {
    private static DoubleLockSingleton instance = null;
    private DoubleLockSingleton() {
    }

    public static DoubleLockSingleton getInstance()
   {
     if (instance == null)
     {
       synchronized(DoubleLockSingleton .class) {  //1
         if (instance == null)          //2
           instance = new DoubleLockSingleton ();  //3
       }
     }
     return instance;
   }
}
Singleton的好处还在于可以节省内存，因为它限制了
实例的个数，有利于Java垃圾回收（garbage collection）。
 
4.发明者是Google公司的Bob lee:
 public   class  Singleton   {  
 
   static   class  SingletonHolder   {  
     static  Singleton instance  =   new  Singleton();  
  }   
 
   public   static  Singleton getInstance()   {  
     return  SingletonHolder.instance;  
  }   
 
}