java 设计模式-装饰模式-decorator

最近又开始学习java的设计模式，实际上应该不是又开始，而是以前学习的不够，现在准备深刻的学习一下，以便在工作中能驾轻就熟的运用设计模式解决实际的问题。
关于设计模式的文章很多，我主要是从github的一个设计模式的例子项目研究的，该项目的地址是：https://github.com/iluwatar/java-design-patterns.git。
我很想知道设计模式在工作中怎么应用，所以我会偏重在现实中找例子学习设计模式，尤其是jdk中的源码。
先从简单的开始吧。
装饰模式-decorator，该项目中提到在现实世界中运用该设计模式的例子是
Collections#synchronizedXXX() Collections#unmodifiableXXX() Collections#checkedXXX()
以unmodifiableCollection(Collection c)为例，该static方法很简单：

public static <T> Collection<T> unmodifiableCollection(Collection<? extends T> c) {
        return new UnmodifiableCollection<>(c);
}

该方法返回了一个实例化的内部静态类。恕我孤陋寡闻，我一看到静态类，就以为是不能实例化，然后就上网搜索了一下java中的内部静态类的用法。该文章很好的解释了静态内部类的使用方法：http://blog.csdn.net/vange/article/details/5407625
在研究的过程中我还发现builder模式用到了内部静态类。

接着说，UnmodifiableCollection该类的代码如下：

static class UnmodifiableCollection<E> implements Collection<E>, Serializable {
        private static final long serialVersionUID = 1820017752578914078L;

        final Collection<? extends E> c;

        UnmodifiableCollection(Collection<? extends E> c) {
            if (c==null)
                throw new NullPointerException();
            this.c = c;
        }

        public int size()                   {return c.size();}
        public boolean isEmpty()            {return c.isEmpty();}
        public boolean contains(Object o)   {return c.contains(o);}
        public Object[] toArray()           {return c.toArray();}
        public <T> T[] toArray(T[] a)       {return c.toArray(a);}
        public String toString()            {return c.toString();}

        public Iterator<E> iterator() {
            return new Iterator<E>() {
                private final Iterator<? extends E> i = c.iterator();

                public boolean hasNext() {return i.hasNext();}
                public E next()          {return i.next();}
                public void remove() {
                    throw new UnsupportedOperationException();
                }
            };
        }

        public boolean add(E e) {
            throw new UnsupportedOperationException();
        }
        public boolean remove(Object o) {
            throw new UnsupportedOperationException();
        }

        public boolean containsAll(Collection<?> coll) {
            return c.containsAll(coll);
        }
        public boolean addAll(Collection<? extends E> coll) {
            throw new UnsupportedOperationException();
        }
        public boolean removeAll(Collection<?> coll) {
            throw new UnsupportedOperationException();
        }
        public boolean retainAll(Collection<?> coll) {
            throw new UnsupportedOperationException();
        }
        public void clear() {
            throw new UnsupportedOperationException();
        }
    }

对于所有的增删操作都会抛出UnsupportedOperationException异常，而对于读取操作，只是调用了原来的Collection类的方法。这样就实现了Collection不能修改的功能。
在Collections.synchronizedCollection(Collection c)也是差不多的实现，在内部静态类SynchronizedCollection中有一个fieldObject mutex做为互斥锁，对于Collection所有的操作都做了以下修改：

public int size() {
            synchronized (mutex) {return c.size();}
        }

http://www.cnblogs.com/cangqiongbingchen/p/5806757.html
该文章对synchroized的使用有简单的介绍，该文章的的第三条需要注意。
SynchronizedCollection中的方法使用的是类实例锁，当mutex=this的时候，synchroized的方法之间都是同步的。通过java语法上的加锁机制实现了Collection的同步，实现该功能的模式就是装饰模式。