设计模式

 关注
发布于: 2020 年 06 月 24 日
单例模式饿汉模式（私有构造器）
保证外部不能调用构造函数创建对象，创建对象的行为只能由这个类决定
public class Singleton {  
     private static Singleton instance = new Singleton();  
     
#    public Singleton (){
#     }
﻿
     private Singleton (){
     }
     public static Singleton getInstance() {  
     return instance;  
     }  
}  
这种方式在类加载时就完成了初始化，所以类加载较慢，但获取对象的速度快。 这种方式基于类加载机制避免了多线程的同步问题，但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化instance显然没有达到懒加载的效果。
﻿
 懒汉模式（线程不安全）
public class Singleton {  
      private static Singleton instance;  
      private Singleton (){
      }   
      public static Singleton getInstance() {  
      if (instance == null) {  
          instance = new Singleton();  
      }  
      return instance;  
      }  
 }
﻿
懒汉模式申明了一个静态对象，在用户第一次调用时初始化，虽然节约了资源，但第一次加载时需要实例化，反映稍慢一些，而且在多线程不能正常工作
懒汉模式（线程安全）
public class Singleton {  
      private static Singleton instance;  
      private Singleton (){
      }
      public static synchronized Singleton getInstance() {  
      if (instance == null) {  
          instance = new Singleton();  
      }  
      return instance;  
      }  
 }  
﻿
这种写法能够在多线程中很好的工作，但是每次调用getInstance方法时都需要进行同步，造成不必要的同步开销，而且大部分时候我们是用不到同步的，所以不建议用这种模式。
双重检查模式 （DCL）
public class Singleton {  
  private volatile static Singleton instance;  
  private Singleton (){
  }   
  public static Singleton getInstance() {  
      if (instance== null) {  
          synchronized (Singleton.class) {  
          if (instance== null) {  
              instance= new Singleton();  
          }  
         }  
     }  
     return singleton;  
     }  
 }  
﻿
这种写法在getSingleton方法中对singleton进行了两次判空，第一次是为了不必要的同步，第二次是在singleton等于null的情况下才创建实例。在这里用到了volatile关键字，volatile关键字能禁止指令重排序，所以volatile能在一定程度上保证有序性。
 静态内部类单例模式
public class Singleton { 
    private Singleton(){
    }
      public static Singleton getInstance(){  
        return SingletonHolder.sInstance;  
    }  
    private static class SingletonHolder {  
        private static final Singleton sInstance = new Singleton();  
    }  
} 
﻿
第一次加载Singleton类时并不会初始化sInstance，只有第一次调用getInstance方法时虚拟机加载SingletonHolder 并初始化sInstance ，这样不仅能确保线程安全也能保证Singleton类的唯一性，所以推荐使用静态内部类单例模式。
 枚举单例
public enum Singleton {       
    INSTANCE;       
    public void doSomeThing() {}   
}  
﻿
为什么要用枚举单例?私有化构造器并不保险享有特权的客户端可以借助AccessibleObject.setAccessible方法，通过反射机制调用私有构造器。如果需要低于这种攻击，可以修改构造器，让它在被要求创建第二个实例的时候抛出异常
   Singleton s=Singleton.getInstance();
   Constructor<Singleton> constructor=Singleton.class.getDeclaredConstructor();
   constructor.setAccessible(true);
   Singleton sReflection=constructor.newInstance();
﻿
序列化问题
       Singleton singleton = Singleton.getInstance();
       ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("SerSingleton.obj"));
       oos.writeObject(s);
       oos.flush();
       oos.close();
﻿
       FileInputStream fis = new FileInputStream("SerSingleton.obj");
       ObjectInputStream ois = new ObjectInputStream(fis);
       Singleton deserializeSingleton = (ingleton)ois.readObject();
       ois.close();
       
       singleton != deserializeSingleton
任何一个readObject方法，不管是显式的还是默认的，它都会返回一个新建的实例，这个新建的实例不同于该类初始化时创建的实例（《effective java》第77条）
不支持反射枚举对象
@CallerSensitive
public T newInstance(Object ... initargs)
    throws InstantiationException, IllegalAccessException,
           IllegalArgumentException, InvocationTargetException
{
    if (!override) {
        if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
            Class<?> caller = Reflection.getCallerClass();
            checkAccess(caller, clazz, null, modifiers);
        }
    }
# 反射在通过newInstance创建对象时，会检查该类是否ENUM修饰，如果是则抛出异常，反射失败
    if ((clazz.getModifiers() & Modifier.ENUM) != 0)
        throw new IllegalArgumentException("Cannot reflectively create enum objects");
    ConstructorAccessor ca = constructorAccessor;   // read volatile
    if (ca == null) {
        ca = acquireConstructorAccessor();
    }
    @SuppressWarnings("unchecked")
    T inst = (T) ca.newInstance(initargs);
    return inst;
}
﻿
枚举可避免序列化问题        枚举序列化的时候Java仅仅是将枚举对象的name属性输出到结果中，反序列化的时候则是通过java.lang.Enum的valueOf方法来根据名字查找枚举对象。
普通的Java类的反序列化过程中，会通过反射调用类的默认构造函数来初始化对象。所以，即使单例中构造函数是私有的，也会被反射给破坏掉。由于反序列化后的对象是重新new出来的，所以这就破坏了单例。
﻿
策略模式什么是策略模式
﻿
在策略模式（Strategy Pattern）中，一个类的行为或其算法可以在运行时更改。这种类型的设计模式属于行为型模式。
在策略模式中，我们创建表示各种策略的对象和一个行为随着策略对象改变而改变的 context 对象。策略对象改变 context 对象的执行算法。
﻿
创建实例﻿
创建一个接口。
Strategy.java
public interface Strategy { 
public int doOperation(int num1, int num2);
}
﻿
步骤 2
创建实现接口的实体类。
OperationAdd.java
public class OperationAdd implements Strategy{ 
@Override 
public int doOperation(int num1, int num2) 
{ 
	return num1 + num2; 
}
}
﻿
OperationSubtract.java
public class OperationSubtract implements Strategy{ 
@Override 
  public int doOperation(int num1, int num2) 
  { 
		return num1 - num2; 
  }
}
﻿
OperationMultiply.java
public class OperationMultiply implements Strategy{ 
@Override 
public int doOperation(int num1, int num2) { 
	return num1 * num2; 
  }
}
﻿
步骤 3
创建 Context 类。
Context.java
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);
   }
}
﻿
步骤 4
使用 Context 来查看当它改变策略 Strategy 时的行为变化。
StrategyPatternDemo.java
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 OperationSubtract());      
      System.out.println("10 - 5 = " + context.executeStrategy(10, 5));
 
      context = new Context(new OperationMultiply());    
      System.out.println("10 * 5 = " + context.executeStrategy(10, 5));
   }
}
﻿
步骤 5
执行程序，输出结果：
10 + 5 = 15
10 - 5 = 5
10 * 5 = 50
﻿
组合模式组合模式（Composite Pattern），又叫部分整体模式，是用于把一组相似的对象当作一个单一的对象。组合模式依据树形结构来组合对象，用来表示部分以及整体层次。这种类型的设计模式属于结构型模式，它创建了对象组的树形结构。
组合模式组合多个对象形成树形结构以表示“整体-部分”的结构层次。
组合模式对单个对象(叶子对象)和组合对象(组合对象)具有一致性，它将对象组织到树结构中，可以用来描述整体与部分的关系。同时它也模糊了简单元素(叶子对象)和复杂元素(容器对象)的概念，使得客户能够像处理简单元素一样来处理复杂元素，从而使客户程序能够与复杂元素的内部结构解耦。
在使用组合模式中需要注意一点也是组合模式最关键的地方：叶子对象和组合对象实现相同的接口。这就是组合模式能够将叶子节点和对象节点进行一致处理的原因。
﻿
组合模式主要包含如下几个角色：
1.Component ：组合中的对象声明接口，在适当的情况下，实现所有类共有接口的默认行为。声明一个接口用于访问和管理Component子部件。
2.Leaf：叶子对象。叶子结点没有子结点。
3.Composite：容器对象，定义有枝节点行为，用来存储子部件，在Component接口中实现与子部件有关操作，如增加(add)和删除(remove)等。
﻿
发布于: 2020 年 06 月 24 日阅读数: 32
张瑞浩

 关注
还未添加个人签名 2018.09.18 加入
还未添加个人简介
发布
暂无评论
设计模式

单例模式

懒汉模式（线程不安全）

懒汉模式（线程安全）

双重检查模式 （DCL）

静态内部类单例模式

枚举单例

为什么要用枚举单例?

私有化构造器并不保险

序列化问题

不支持反射枚举对象

枚举可避免序列化问题

策略模式

什么是策略模式

创建实例

组合模式

张瑞浩

评论

双重检查模式（DCL）
