设计模式

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();   
    }   
}