Java设计模式思想及其在源码中的应用实例（持续更新...）

一. 重点掌握

单例模式

定义：

• 保证一个类有且仅有一个实例，并提供一个访问它的全局访问点。

实现：

• 饿汉式：

public class Singleton {
   
    
    private static Singleton instance = new Singleton();
    
    //私有化构造器
    private Singleton() {
   };
    
    public static Singleton getInstance() {
   
        return instance;
    }
}

  弊端：instance对象不管是否调用都会创建出来，占用系统内存同时还会增加类初始化的时间。
  好处：获取对象速度快，线程安全。

• 饱汉式：延迟加载，用到时再加载Instance实例。
  • 为适应多线程环境，可直接在getInstance方法上加上synchronized关键字，但付出的代价就是每次获取实例时都加上锁带来的额外性能开销。

（1）双重检查锁实现

public class DoubleCheckLock {
   
    //volatile关键字是必要的 （通过写屏障保证可见性与有序性）
    private static volatile DoubleCheckLock instance = null;
    private DoubleCheckLock() {
   }

    /**
     * 第一层判断是为了避免不必要的加锁
     * 加了锁之后的第二层判断才是真正可以解决并发问题的关键
     */
    public static DoubleCheckLock getInstance() {
   
        if(instance == null) {
   
            synchronized (DoubleCheckLock.class) {
   
                if(instance == null) {
   
                    instance = new DoubleCheckLock();
                }
            }
        }
        return instance;
    }
}

（2）静态内部类实现

public class StaticClass {
   
    private StaticClass() {
   }
    //内部类不会被立即加载，只有当调用到其中的成员变量时才会加载
    private static class StaticIndoor {
   
        private final static StaticClass instance = new StaticClass();
    }
    public static StaticClass getInstance() {
   
        return StaticIndoor.instance;
    }
}

以上两种方式都是延迟加载获取对象同时保证线程安全的实现，推荐使用。

工厂模式

定义：

• 工厂模式包括三种：简单工厂模式、工厂方法模式、抽象工厂模式
  • 简单工厂：将创建对象的职责封装到一个类中，由该工厂类统一创建对象。
  • 工厂方法模式： 为了解决简单工厂模式下工厂类可能变为超级类的问题，引入工厂方法模式，每一种对象的创建都对应一种工厂类。虽然看起来增加了工厂类和用户类间的耦合关系，但是可以将对象的创建细节完全封装到工厂类中。
  • 抽象工厂模式：进一步向上提取抽象接口，用户端统一调用接口对象，具体实现交由实现类完成。适合纵向拓展业务（新增工厂）而不适合横向拓展（新增接口方法）。

实现：

• 简单工厂示意：

public class Factory{
   
    public static ISample creator(int which){
   
        if (which==1)
            return new SampleA();
        else if (which==2)
            return new SampleB();
    }
}

• 工厂方法模式示意：

public class SampleAFactory {
   
	public static ISample creator() {
   
		return<