PS：首先我们要带着问题读文章

什么是设计模式

为什么要用设计模式

使用设计模式有什么好处

　　设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了重用代码、让代码更容易被他人理解、保证代码可靠性。 毫无疑问，设计模式于己于他人于系统都是多赢的，设计模式使代码编制真正工程化，设计模式是软件工程的基石，如同大厦的一块块砖石一样。项目中合理地运用设计模式可以完美地解决很多问题，每种模式在现实中都有相应的原理来与之对应，每种模式都描述了一个在我们周围不断重复发生的问题，以及该问题的核心解决方案，这也是设计模式能被广泛应用的原因。

　　　该篇文章主要写的是（介绍没有顺序）

适配器设计模式

单例设计模式

静态代理设计模式

简单工厂设计模式

1：适配器设计模式

意图：将一个类的接口转换成客户希望的另外一个接口。适配器模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。

主要解决：主要解决在软件系统中，常常要将一些"现存的对象"放到新的环境中，而新环境要求的接口是现对象不能满足的。

官方给出：

优点： 1、可以让任何两个没有关联的类一起运行。 2、提高了类的复用。 3、增加了类的透明度。 4、灵活性好。

缺点： 1、过多地使用适配器，会让系统非常零乱，不易整体进行把握。比如，明明看到调用的是 A 接口，其实内部被适配成了 B 接口的实现，一个系统如果太多出现这种情况，无异于一场灾难。因此如果不是很有必要，可以不使用适配器，而是直接对系统进行重构。 2.由于 JAVA 至多继承一个类，所以至多只能适配一个适配者类，而且目标类必须是抽象类。

示例：这里我简单写一个关于两个接口的例子，来调用里面的方法来看看效果这两个接口我们可以理解成充电器，一个是苹果lighting口，一个安卓充电器，我们都知道这两个充电器接口是不一样的，但是淘宝上有卖转换头的，可以在苹果头上套一个转换器就可以冲安卓手机里，这中间的转换头就是我们所说的适配器，我再配张图（中间一头是方形一头是圆形就是适配器）

好，废话不多说，开始

（1）首先写一个A苹果接口，一个B安卓接口然后实现该接口里的方法，开始工作

//实现A

class PowerA {

public void workA(){}

}

class PowerAiml extends PowerA{

public void workA(){

System.out.println("我是A，我要开始工作了");

}

}

//实现B

class PowerB {

public void workB(){}

}

class PowerBiml extends PowerB{

public void workB(){

System.out.println("我是B，我要开始工作了");

}

}

（2）写一个方法只有A（苹果）接口可以用。

public static void work(PowerA a){

System.out.println("开始-------");

a.workA();

System.out.println("结束-------");

}

（3）调用查看效果

PowerA pa=new PowerAiml();

work(pa);

这样使用是没有任何问题的，因为参数就是PowerA a，只要是传入实现PowerA接口的class都可以调用该方法，但是，问题来了，如果我想让使用PowerB怎么办呢，有两个方法，一个是再写一个work2（PowerB b），另一个是用适配器的方法，显然第一种方法对于这个例子是最简单的，但是在一个软件编写的过程中不光是这一点代码，代码有很多，难道都要再写方法吗，那样子就太麻烦了，现在就用适配器的方法

（4）适配器

想要使用A方法，就要伪装成A，把适配器实现PowerA

//适配器：

class Adapter1 extends PowerA{

public PowerB b;

public Adapter1(PowerB b){

this.b=b;

}

//当调用A的时候，就自动调用B里的方法。

public void workA(){

b.workB();

}

}

调用的时候是，一头与B关联，一头与A关联

PowerB b=new PowerBiml();

Adapter1 adapter=new Adapter1(b);

work(adapter);

解释一下：在Adapter1中传入的b，然后把adapter传入work，虽然调用的都是workA，但是关键来了，在workA方法中又调用了b.workB()；就是这么一个思路。

这是一个非常简单的例子，在开发过程中，真正要用到适配器要比这个看似复杂点，原理都是一样的，毕竟小孩子的性格是天真的，大人的性格就变化莫测了。

2：代理设计模式

意图：为其他对象提供一种代理以控制对这个对象的访问。

主要解决：在直接访问对象时带来的问题，比如说：要访问的对象在远程的机器上。在面向对象系统中，有些对象由于某些原因（比如对象创建开销很大，或者某些操作需要安全控制，或者需要进程外的访问），直接访问会给使用者或者系统结构带来很多麻烦，我们可以在访问此对象时加上一个对此对象的访问层。

何时使用：想在访问一个类时做一些控制。

如何解决：增加中间层。

静态代理模式，说白了就是委托，将所有的事情都委托给别人帮你完成，你所要做的，就是给代理一些东西，接下来所有的事情都是代理帮你完成，你完全不用去关心内部是如何实现的。举个例子简单的说一下，一个人买衣服，可以去实体店也可以去网上，买火车票的时候，你就知道售票员就会给你 你想要的票，而且你只需要给他钱和身份证以及地点就可以了，他会经过处理，最后把票给你，他就处于一个代理模式。下面我简单写一个例子

比如说我只想要水，我就给你送水的公司打电话让他们送一桶水，然后我就在家等着就可以，在这期间谁送水，怎么送，需要多久，什么样的水等一切我都不需要知道，这都被送水公司代理了。OK

（1）先写一个要水的类和接口

class Action{

public void work(){}

}

class MyAction extends Action{

public void work(){

//在这期间可能会有我不想做的事，但还是要有，比如说一共耗时，打水结果要的是水，但必需要拿水桶等。

//这些东西都是可以让代理给做了，

System.out.println("获得水");

}

}

（2）写代理类

如果不写代理类的话，也可以直接调用work方法，但是就相当于自己去搬水，而不是用代理。

/**

* 代理类

* 控制，在方法前或后所要做的类。

* */

class DaiLiAction extends Action{

private Action action;

public DaiLiAction(Action action){

this.action=action;

}

public void work(){

System.out.println("我是送水公司");

System.out.println("代理正在处理中。。。");

System.out.println("代理处理完了返回给你结果");

action.work();

}

}

（3）调用即可

Action ac=new MyAction();

//把对象给代理类，工作是由代理完成。

DaiLiAction dai=new DaiLiAction(ac);

dai.work();

3：单例设计模式

http://www.cnblogs.com/cmusketeer/p/8016550.html

4:简单工厂设计模式

意图：定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。

主要解决：主要解决接口选择的问题。

何时使用：我们明确地计划不同条件下创建不同实例时。

如何解决：让其子类实现工厂接口，返回的也是一个抽象的产品。

哦，对了，这是简单工厂设计模式，还有抽象工厂设计模式，和这个类似，下一篇再说，这里先举例说明这个模式，使用该模式可以降低使用者和被使用者之间的依赖。比如说，我开了一个工厂，下面有部门，一个是造手机的，一个是造电脑的，OK

（1）创建手机和电脑类

/**

* 工厂接口

* */

interface Factory1{

public void create();

}

/**

* 手机

* */

class Phone implements Factory1{

@Override

public void create() {

System.out.println("我是造--手机--的");

}

}

/**

* 电脑

* */

class Computer implements Factory1{

@Override

public void create() {

System.out.println("我是造--电脑--的");

}

}

（2）创建工厂控制类FactoryControl

/**

* 工厂控制类

* */

class FactoryControl{

public static Factory1 getGood(String good){

if(good.equalsIgnoreCase("phone")){

return new Phone();

}else if(good.equalsIgnoreCase("computer")){

return new Computer();

}

return null;

}

}

(3)调用和效果

Factory1 factory=FactoryControl.getGood("phone");

factory.create();

factory=FactoryControl.getGood("computer");

factory.create();

当然，也可以不经过FactoryControl（工厂类）,也是可以调用的，但是如果是大工程，使用该模式可以降低使用者和被使用者之间的依赖。这里就算你传入一个耳机，没有这个功能，它也不会报错，返回null。

好了，下一篇就会继续写剩下的19个设计模式，例子都是简单易懂的，只要理解了，慢慢的再写复杂的代码就轻松了，只要有了思想，写代码就简单了，可以告别有能力但总觉得无处施展的尴尬。