设计模式

http://www.runoob.com/design-pattern/factory-pattern.html

创建型模式

结构型模式

行为型模式

J2EE 模式


单例模式

双重检测

public class Singleton {  
    private volatile static Singleton singleton;  
    private Singleton (){}  
    public static Singleton getSingleton() {  
    if (singleton == null) {  
        synchronized (Singleton.class) {  
        if (singleton == null) {  
            singleton = new Singleton();  
        }  
        }  
    }  
    return singleton;  
    }  
}

私有静态类

public class Singleton {  
    private static class SingletonHolder {  
        private static final Singleton INSTANCE = new Singleton();  
    }  
    private Singleton (){}  
    public static final Singleton getInstance() {  
    return SingletonHolder.INSTANCE;  
    }  
}

枚举方式

public enum Singleton {  
    INSTANCE;  
    public void whateverMethod() {  
    }  
}

工厂模式

总结:
- 简单工厂模式:1种产品+1个工厂实现类
- 工厂模式:1种产品+多个工厂实现类
- 抽象工厂模式:多种产品+多个工厂实现类

简单工厂: 只有一个Factory

简单工厂
简单工厂模式

工厂模式: 多个工厂只生产一种产品

工厂模式

抽象工厂模式: 有多个工厂,不止生产一种产品

抽象工厂


观察者模式

观察者模式

  1. Subject中包含观察者List;
  2. 观察者类中包含Subject对象;

观察者

java中已经实现了相关的接口:

java.util.Observable: 这是一个类,而非接口,主题需要继承这个类
java.util.Observer: 这是一个接口,监听者需要实现这个接口

观察者模式 vs 发布-订阅模式

发布 + 订阅 = 观察者模式 ? 不完全相同,可参见: https://juejin.im/post/5a14e9edf265da4312808d86

区别:
观察者模式 vs 发布订阅设计模式

发布订阅设计模式(类似rabbitmq消息队列)
发布订阅模式


建造者模式


装饰器模式

Java类库中用到该模式的地方: 1. InputStream/OutStream
2. Collections.synchorizedXXXX:同步容器类;

要点:
1. 装饰器抽象类:必须实现被装饰对象的Interface
2. 装饰器抽象类:包含被装饰对象的引用;
3. 构造函数:使用被装饰对象构造

装饰器


策略模式

策略

// 具体策略
public interface Strategy {
   public int doOperation(int num1, int num2);
}


public class OperationAdd implements Strategy{
   @Override
   public int doOperation(int num1, int num2) {
      return num1 + num2;
   }
}

public class OperationSubstract implements Strategy{
   @Override
   public int doOperation(int num1, int num2) {
      return num1 - num2;
   }
}


public class OperationMultiply implements Strategy{
   @Override
   public int doOperation(int num1, int num2) {
      return num1 * num2;
   }
}

// 具体使用策略的Context
public class Context {
   private Strategy strategy;

   public Context(Strategy strategy){
      this.strategy = strategy;
   }

   public int executeStrategy(int num1, int num2){
      return strategy.doOperation(num1, num2);
   }
}


public class StrategyPatternDemo {
   public static void main(String[] args) {
      Context context = new Context(new OperationAdd());    
      System.out.println("10 + 5 = " + context.executeStrategy(10, 5));

      context = new Context(new OperationSubstract());      
      System.out.println("10 - 5 = " + context.executeStrategy(10, 5));

      context = new Context(new OperationMultiply());    
      System.out.println("10 * 5 = " + context.executeStrategy(10, 5));
   }
}

模板模式

模板

public abstract class Game {
   abstract void initialize();
   abstract void startPlay();
   abstract void endPlay();

   //模板
   public final void play(){

      //初始化游戏
      initialize();

      //开始游戏
      startPlay();

      //结束游戏
      endPlay();
   }
}


public class Cricket extends Game {

   @Override
   void endPlay() {
      System.out.println("Cricket Game Finished!");
   }

   @Override
   void initialize() {
      System.out.println("Cricket Game Initialized! Start playing.");
   }

   @Override
   void startPlay() {
      System.out.println("Cricket Game Started. Enjoy the game!");
   }
}