设计模式二

结构模式

结构模式包含下面7种模式，他们之间的发展关系如图。

适配器设计模式

概述：适配器模式就是将一种类型转换成另外一种类型，解决类之间的兼容性问题。
实现方式：适配器类药继承自适配源类，实现目标类的接口，适配器内部实际上调用的是适配源类的方法。
使用：在需要使用目标类的地方直接创建适配器对象。
扩展：这里介绍的是类适配器，还有对象适配器，接口适配器。

/**
 * 源类，待适配
 * @author Administrator
 */
public class Source {
public void sourceMethod(){
    System.out.println("I am soucrce method.");
}
}
/**
 * 适配器的目标类
 * @author Administrator
 */
public interface Target {
    public void method1();

    public void method2();
}
/**
 * 适配器类：适配器类用来把一个类转换成另外一个类，解决类型不兼容问题
 * 
 * 适配器有类适配器,接口适配器,对象适配器
 * 
 * 对象适配器:对象适配器和类适配器非常相似,只是这里的Adpter是继承自Source.对象适配器
 * 不是继承自Source,而是将Source对象当作参数传入Adpter中，再调用它的方法，达到适配的目的。
 * 
 * 接口适配器：接口适配器不是将接口转换成另外一个接口。使用接口适配器的情况是：当一个接口的方法很多时
 * ，有时并不是所有的方法我们都回用到。这里我们可以使用一个抽象类实现这个接口的所有方法，然后我们再继承
 * 这个抽象类只复写我们关注的类。这样我们的代码看起来会更简洁一些。
 *
 *讲了这么多，总结一下三种适配器模式的应用场景：

 *类的适配器模式：当希望将一个类转换成满足另一个新接口的类时，可以使用类的适配器模式，创建一个新类，继承原有的类，实现新的接口即可。

 *对象的适配器模式：当希望将一个对象转换成满足另一个新接口的对象时，可以创建一个Wrapper类，持有原类的一个实例，在Wrapper类的方法中，调用实例的方法就行。

 *接口的适配器模式：当不希望实现一个接口中所有的方法时，可以创建一个抽象类Wrapper，实现所有方法，我们写别的类的时候，继承抽象类即可。
 */
public class Adapter extends Source implements Target {

    @Override
    public void method1() {
        sourceMethod();

    }

    @Override
    public void method2() {
        System.err.println("target method.");

    }

}
/*
 * 客户端
 */
public class Client {

    public static void main(String[] args) {
        Target target=new Adapter();
        target.method1();
        target.method2();

    }

}

装饰设计模式

概述：所谓装饰设计模式就是在原有类的基础上动态的添加一些功能，而不是使用继承。
实现：实现和被装饰类同样的接口。同时包含一个被装饰类的引用。

/*
 * 被装饰类接口
 */
public interface ISource {
public void Method();
}
/**
 * 被装饰类
 */
public class Source implements ISource{

    @Override
    public void Method() {
        System.out.println("I am source");

    }

}
/**
 * 装饰类
 * 装饰模式就是给一个对象增加一些新的功能，而且是动态的，
 * 要求装饰对象和被装饰对象实现同一个接口，
 * 装饰对象持有被装饰对象的实例
 */
public class Decotator implements ISource {
    private ISource source;

    public Decotator(ISource source) {
        this.source = source;
    }

    @Override
    public void Method() {
        source.Method();
        System.out.println("I am decorator");
    }
}
/*
 * 客户端
 */
public class Client {
    public static void main(String args[]) {
        // no decorator
        ISource source = new Source();
        source.Method();
        System.out.println("----------");
        // decorator
        source = new Decotator(source);
        source.Method();
    }
}

代理设计模式

概述：代理从名字上就可以看出来，代理模式代替原有类的工作。
实现：实现和被装饰类同样的接口。同时包含一个被装饰类的引用。

和装饰设计模式的区别：从实现上来看，基本上是差不多的。但是代理模式中引用的被代理对象一般是在代理类的内部直接创建的，而不是通过参数传递的。

public interface ISource {
    public void DoAction();
}
public class Source implements ISource {

    @Override
    public void DoAction() {
        System.out.println("I am doing work.");

    }

}
/*
 * 代理实现了和被代理对象相同的接口，代替代理对象的工作并添加一些额外的操作。
 * 
 * 代理和装饰 的区别：
 * 最主要的区别是代理模式中被代理的对象是在代理对象中创建的不是以参数的形式传递近来。
 * 一般来说使用代理模式的时候被代理的对象 都已近确定了。
 * 
 * 我们可以用另外一句话来总结这些差别：使用代理模式，代理和真实对象之间的的关系通常在编译时就已经确定了，
 * 而装饰者能够在运行时递归地被构造
 */
public class Proxy implements ISource {
    private ISource source;

    public Proxy() {
        this.source = new Source();
    }

    @Override
    public void DoAction() {
        System.out.println("before proxy");
        this.source.DoAction();
        System.out.println("after proxy");
        ;
    }

}
public class Client {

    public static void main(String[] args) {
        ISource source = new Proxy();
        source.DoAction();

    }

}

外观设计模式

对外观模式的理解：外观模式就是屏蔽系统内部的复杂性，对外展示一个统一的简洁的接口，供使用者调用。

例如：电脑的启动过程是比较的复杂的。但是这里我们举一个不恰当的例子，开启电脑要开启CPU，内存，硬盘等一系列硬件。但是为了让使用者使用起来比较方便，可以使用外观模式来屏蔽内部的复杂性。对于使用者来说只要“一键开机”就可以开启计算机。

public class CPU {
    public void start(){
        System.out.println("cpu start");
    }
    public void ShutDown(){
        System.out.println("cpu shut down");
    }
}
public class Disk {
    public void start(){
        System.out.println("disk start");
    }
    public void ShutDown(){
        System.out.println("disk shut down");
    }
}
public class Memmory {
    public void start(){
        System.out.println("memmory start");
    }
    public void ShutDown(){
        System.out.println("memmory shut down");
    }
}
//外观，内部包含有各自系统的引用
public class Computer {
    CPU cpu = new CPU();
    Memmory memmory = new Memmory();
    Disk disk = new Disk();

    public void start() {
        cpu.start();
        memmory.start();
        disk.start();
        System.out.println("computer start");
    }

    public void ShutDown() {
        cpu.ShutDown();
        memmory.ShutDown();
        disk.ShutDown();
        System.out.println("computer shutdown");
    }
}
/**
 * 外观模式它的目的在于如何简化接口，它可以将多个
类的复杂的一切隐藏在背后，只显露出一个干净美观的外观。
 *
 */
public class User {
    public static void main(String args[]){
        Computer computer=new Computer();
        computer.start();
    }

}

桥接设计模式

对桥接设计模式的理解:官方对桥接设计模式的理解是将抽象化与实现化解耦，使得二者可以独立变化.我的理解是,对于俩个相互关联但是变化都比较大的类我们可以使用桥接模式来解决.参考：http://blog.csdn.net/jason0539/article/details/22568865桥接模式使得这2个类可以独立的变而互不影响。相当于是解除了俩个类之间的耦合度。
桥接模式的实现：桥接模式的原理就是将俩个变化维度比较大的类都进行抽象，使得这俩个类通过各自的抽象联系在一起，这样就解除了俩个实现类之间的联系。我们在使用的时候调用的都是接口而和具体的实现没有关系。
桥接模式的例子：
http://blog.csdn.net/jason0539/article/details/22568865

组合设计模式

对组合设计模式的说明：
首先组合设计模式适用的范围：是处理树型数据结构的情况。比如：文件目录，分级目录等。
原理：不论是树型的叶子还是节点都实现了相同的接口或抽象类（这个抽象类必须包含增加和删除节点的方法，如果需要还可以添加其他的方法）。这样客户端在处理的时候就对于处理的节点和叶子是没有区别的。节点在实现接口的同时需要维护一个容器来存放叶子。叶子在实现接口的时候是不需要维护容器，因为叶子下边没有节点，因此也不需要实现处理容器的方法。

下面给出一个例子，并对组合设计模式做一个小的扩展：

/*
 * 叶子和节点的公共类
 */
public abstract class Component {
    protected String name;

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

    public abstract void add(Component component);

    public abstract void remove(Component component);
    /**
     * depath 处于树型结构第几级
     */
    public abstract void Display(int depath);   
}
/*
 * 叶子实现接口但是不行需要维护一个容器,同样也不需要实现维护容器的方法.
 * 这里的叶子还实现一个额外的方法Display,来展示自身的信息.
 */
public class Leaf extends Component {

    public Leaf(String name) {
        super(name);
    }

    @Override
    public void add(Component component) {
        // TODO Auto-generated method stub

    }

    @Override
    public void remove(Component component) {
        // TODO Auto-generated method stub

    }

    /**
     * depath 处于树型结构第几级
     */
    @Override
    public void Display(int depath) {
        String temp = "";
        for (int i = 0; i < depath; i++)
            temp += ‘-‘;
        System.out.println(temp + name);

    }

}

import java.util.ArrayList;
import java.util.List;
/**
 *节点维护一个容器且实现维护该容器的方法。
 *同时实现一个额外的方法。这个额外的方法与叶子的不同之处是，它还要遍历每一个子节点然后调用每一个节点的DisPlay方法实现递归。
 */
public class Composite extends Component {
    private List<Component> child = new ArrayList<Component>();

    public Composite(String name) {
        super(name);
    }

    @Override
    public void add(Component component) {
        child.add(component);
    }

    @Override
    public void remove(Component component) {
        child.remove(component);
    }

    @Override
    public void Display(int depth) {
        String temp = "";
        for (int i = 0; i < depth; i++)
            temp += ‘-‘;
        System.out.println(temp + name);

        for (Component c : child) {
            c.Display(depth + 2);
        }

    }

}

public class CompositePattern {

    public static void main(String[] args) {
         Composite root = new Composite("root");
            root.add(new Leaf("Leaf A"));
            root.add(new Leaf("Leaf B"));

            Composite compX = new Composite("Composite X");
            compX.add(new Leaf("Leaf XA"));
            compX.add(new Leaf("Leaf XB"));
            root.add(compX);

            Composite compXY = new Composite("Composite XY");
            compXY.add(new Leaf("Leaf XYA"));
            compXY.add(new Leaf("Leaf XYB"));
            compX.add(compXY);

            root.Display(1);
    }

}

享元设计模式

用途：避免创建大量的相同对象，实现对象共享。线程池中很明显使用了这种设计模式。

实现：当一个客户端请求获取一个对象的时候，如果这个对象存在，那么就直接返回，如果不存在，那么就先创建这个对象存储起来再返回。这就是享元模式的核心思想。