java中常用的设计模式

Java中一般认为有23种设计模式，我们不需要所有的都会，但是其中常用的几种设计模式应该去掌握。下面列出了所有的设计模式。需要掌握的设计模式我单独列出来了，当然能掌握的越多越好。
总体来说设计模式分为三大类：

1. 创建型模式，共五种：单例模式、工厂方法模式、抽象工厂模式、建造者模式、原型模式。
2. 结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。

1、单例设计模式

最好理解的一种设计模式，分为懒汉式和饿汉式。
饿汉式：

public class Singleton {
  // 直接创建对象
  public static Singleton instance = new Singleton();
  // 私有话构造函数
  private Singleton(){
  }
  // 返回对象实例
  public static Singleton getInstance(){
    return instance;
  }
}

懒汉式：

public class Singleton {
  // 直接创建对象
  public static Singleton instance = null;
  // 私有话构造函数
  private Singleton(){
  }
  // 返回对象实例
  public static Singleton getInstance(){
    if(instance == null) {
      synchronized(Singleton.class){
        if(instance == null) {
          instance = new Singleton();
        }
      }
    }
    return instance;
  }
}

2、工厂模式（略）

3、建造者模式Builder

工厂类模式提供的是创建单个类的模式，而建造者模式则是将各种产品集中起来进行管理，用来创建复合对象，
所谓复合对象就是指某个类具有不同的属性。

public class Builder { 
  private List<Sender> list = new ArrayList<Sender>(); 
  public void produceMailSender(int count) {
    for (int i=0; i<count; i++) {
      list.add(new SmsSender());
    }
  }
  public void produceSmsSender(int count) {
    for (int i=0; i<count; i++) {
      list.add(new SmsSender());
    }
  }
}

public class TestBuilder { 
  public static void main(String[] args) { 
    Builder builder = new Builder(); 
    builder.produceMailSender(10); 
  }
}

4、适配器设计模式

适配器模式将某个类的接口转换成客户端期望的另一个接口表示，目的是消除由于接口不匹配所造成的类的兼容性问题。主要分为三类：类的适配器模式、对象的适配器模式、接口的适配器模式。
类的适配器：

public class Source {
  public void method1() {
    System.out.println("this is original method!");
  }
} 
public interface Targetable {
  /* 与原类中的方法相同 */
  public void method1();
  /* 新类的方法 */
  public void method2();
} 
public class Adapter extends Source implements Targetable {
  @Override
  public void method2() {
    System.out.println("this is the targetable method!");
  }
}
public class AdapterTest {
  public static void main(String[] args) {
    Targetable target = new Adapter();
    target.method1();
    target.method2(); 
  }
}

对象适配器：

public class Wrapper implements Targetable {
  private Source source;
  public Wrapper(Source source) {
    super();
    this.source = source;
  }
  @Override
  public void method2() {
    System.out.println("this is the targetable method!");
  } 
  @Override
  public void method1() {
    source.method1();
  } 
}
public class AdapterTest {
  public static void main(String[] args) {
    Source source = new Source();
    Targetable target = new Wrapper(source);
    target.method1();
    target.method2();
  }
}

接口适配器：
有时我们写的一个接口中有多个抽象方法，当我们写该接口的实现类时，必须实现该接口的所有方法，这明显有时比较浪费，因为并不是所有的方法都是我们需要的，有时只需要某一些，此处为了解决这个问题，我们引入了接口的适配器模式，借助于一个抽象类，该抽象类实现了该接口，实现了所有的方法，而我们不和原始的接口打交道，只和该抽象类取得联系，所以我们写一个类，继承该抽象类，重写我们需要的方法就行。

5、装饰模式

顾名思义，装饰模式就是给一个对象增加一些新的功能，而且是动态的，要求装饰对象和被装饰对象实现同一个。

public interface Sourceable { 
  public void method(); 
}

public class Source implements Sourceable { 
  @Override
  public void method() {
    System.out.println("the original method!");
  }
}

public class Decorator implements Sourceable {
  private Sourceable source;
  public Decorator(Sourceable source) {
    super();
    this.source = source;
  }
  @Override
  public void method() {
    System.out.println("before decorator!");
    source.method();
    System.out.println("after decorator!");
  }
} 
public class DecoratorTest {
  public static void main(String[] args) {
    Sourceable source = new Source();
    Sourceable obj = new Decorator(source); 
    obj.method();
  }
}

6、策略模式

7、观察者模式