设计模式

1 单例模式

1.1 模式概述

只能生成一个实例的类是实现了单例模式的类型。单例模式作用是保证在整个应用程序周期内，单例类的实例最多有一个。

1.2 实现思想

1) 构造函数私有化，不让其他类调用构造函数
2) 在类中创建一个本类的对象，作为待返回的成员变量
3) 对外提供一个方法，返回该类对象。

1.3 饿汉与懒汉模式

1) 懒汉模式：只有当调用getInstance的时候，才回去初始化这个单例。
2) 饿汉模式：类一旦加载，就把单例初始化完成，保证getInstance的时候，单例是已经存在的了。

线程安全

1) 饿汉模式天生线程安全，可直接用于多线程环境
2) 懒汉模式本生线程不安全，需要额外的保证

资源加载性能

1) 饿汉模式在类加载同时创建类的对象，无论以后是否使用类的对象都会占据内存；由于是加载类时创建，所以第一次调用对象时速度快。
2) 懒汉模式在第一次使用该类实例时才会创建对象；第一次调用时会有延迟。

1.4 代码实现

1) 基本的懒汉模式-线程不安全

构造函数私有化，定义静态的类实例，在需要的时候创建该实例
缺点：当instance==null，且两个线程同时运行至判断语句时，两个线程都会创建对象。

public class Singleton1 {    private static Singleton1 instance = null; //     private Singleton1() {}    public static Singleton1 getInstance() {        if (instance == null)            instance = new Singleton1();        return instance;    }}

2) 懒汉模式-加锁机制使线程安全

-用synchronized关键字或lock锁，使得同一时刻只能有一个线程进入判断语句
缺点：锁的加载与释放非常耗时

public class Singleton2 {    private static Singleton2 instance = null;    private Singleton2() {}    public static synchronized Singleton2 getInstance() {        if (instance == null)            instance = new Singleton2();        return instance;    }}

3) 懒汉模式-加锁前双重校验

-由于锁的加载与释放很耗时，而且只在第一次创建实例时需要加锁，第二次及以后获取实例不需要加锁。所以可以在加锁前进行双重校验。
关于指令重排，见指令重排详细解释

版本一，有指令重排产生的潜在风险

public class Singleton3 {    private static Singleton3 instance = null;    private Singleton3() {}    public static Singleton3 getInstance() {        if (instance == null) {            synchronized(Singleton3.class) {                if (instance == null)                    instance = new Singleton3();            }        }        return instance;    }}

【推荐】版本二，用volatile关键字禁止指令重排

public class Singleton3 {    private static volatile Singleton3 instance = null;    private Singleton3() {}    public static Singleton3 getInstance() {        if (instance == null) {            synchronized(Singleton3.class) {                if (instance == null)                    instance = new Singleton3();            }        }        return instance;    }}

4) 【推荐】饿汉模式

-利用静态成员变量在类加载时就初始化的特性，生成类的唯一对象

public class Singleton4 {    private static Singleton4 instance = new Singleton4();    private Singleton4() {}    public static Singleton4 getInstance() {        return instance;    }}

5) 【推荐】静态内部类

-当Singleton5类被装载时，由于没有调用getInstance()方法，所以类的对象不会被实例化；当显示调用getInstance()方法时，内部类InnerClass被加载，进而内部类中的Singleton5对象被实例化。

public class Singleton5 {    private Singleton5() {}    public static getInstance() {        return InnerClass.instance;    }    private static class InnerClass {        private static Singleton5 instance = new Singleton5();    }}

2 工厂模式

2.1 模式概述

程序在接口和子类之间加入了一个过渡端，通过此过渡端可以动态取得实现了共同接口的子类实例化对象。

2.2 代码实现

interface Animal { // 定义一个动物的接口      public void say(); // 说话方法  }   class Cat implements Animal { // 定义子类Cat      @Override      public void say() { // 覆写say()方法          System.out.println("我是猫咪，喵呜！");       }   }   class Dog implements Animal { // 定义子类Dog      @Override      public void say() { // 覆写say()方法          System.out.println("我是小狗，汪汪！");       }   }   class Factory { // 定义工厂类      public static Animal getInstance(String className) {           Animal a = null; // 定义接口对象          if ("Cat".equals(className)) { // 判断是哪个子类的标记              a = new Cat(); // 通过Cat子类实例化接口          }           if ("Dog".equals(className)) { // 判断是哪个子类的标记              a = new Dog(); // 通过Dog子类实例化接口          }           return a;       }   }   public class FactoryDemo {    public static void main(String[] args) {           Animal a = null; // 定义接口对象          a = Factory.getInstance(args[0]); // 通过工厂获取实例          if (a != null) { // 判断对象是否为空              a.say(); // 调用方法           }       }   } 

3 代理模式

3.1 模式概述

指由一个代理主题来操作真实主题，真实主题执行具体的业务操作，而代理主题负责其他相关业务的处理。比如生活中的通过代理访问网络，客户通过网络代理连接网络（具体业务），由代理服务器完成用户权限和访问限制等与上网相关的其他操作（相关业务）。

3.2 代码实现

interface Network { // 定义Network接口      public void browse(); // 定义浏览的抽象方法  }  class Real implements Network { // 真实的上网操作    public void browse() { // 覆写抽象方法          System.out.println("上网浏览信息！");      }  }  class Proxy implements Network { // 代理上网      private Network network;      public Proxy(Network network) {// 设置代理的真实操作          this.network = network; // 设置代理的子类      }      public void check() { // 身份验证操作          System.out.println("检查用户是否合法！");      }      public void browse() {          this.check(); // 调用具体的代理业务操作          this.network.browse(); // 调用真实的上网操作      }  }  public class ProxyDemo {      public static void main(String args[]) {          Network net = null; // 定义接口对象          net = new Proxy(new Real()); // 实例化代理，同时传入代理的真实操作          net.browse(); // 调用代理的上网操作      }  }  

4 适配器模式

4.1 模式概述

如果一个类要实现一个具有很多抽象方法的接口，但是本身只需要实现接口中的部分方法便可以达成目的，所以此时就需要一个中间的过渡类，但此过渡类又不希望直接使用，所以将此类定义为抽象类最为合适，再让以后的子类直接继承该抽象类便可选择性的覆写所需要的方法，而此抽象类便是适配器类

4.2 代码实现

interface Window {// 定义Window窗口接口，表示窗口操作      public void open();// 窗口打开      public void close();// 窗口关闭      public void iconified();// 窗口最小化      public void deiconified();// 窗口恢复      public void activated();// 窗口活动  }   // 定义抽象类实现接口，在此类中覆写方法，但是所有的方法体为空   abstract class WindowAdapter implements Window {       public void open() {       };// 窗口打开       public void close() {       };// 窗口关闭       public void iconified() {       };// 窗口最小化       public void deiconified() {       };// 窗口恢复       public void activated() {       };// 窗口活动   }   // 子类继承WindowAdapter抽象类，选择性实现需要的方法   class WindowImpl extends WindowAdapter {       public void open() {           System.out.println("窗口打开");// 实现open()方法      }       public void close() {           System.out.println("窗口关闭");// 实现close()方法      }   }   public class AdapterDemo {       public static void main(String args[]) {           Window win = new WindowImpl(); // 实现接口对象          // 调用方法           win.open();           win.close();       }   }