关于设计模式,之前已经看过很多很多了.但是每次到过了很久之后,在此回忆总是感觉有模糊的感觉.这次我要重新学习一下设计模式.并在这里做一个博客记录,以作为以后的备忘吧.大家看过如果有问题或者更好的方式,可以在评论留言
这篇文章也是我写设计模式的开章.主要方式是看视频和看书,设计模式被人称为GOF23 主要就是国外有4个编程牛人编写的这23中设计模式.大家主要理解人家的思想.而不是死记硬背,这句话也是对我自己说的.
设计模式的分类
1.创建型模式:5种
单例模式 工厂模式 抽象工厂模式 建造者模式 原型模式
2.结构型模式 7种
适配模式 桥接模式 装饰模式 组合模式 外观模式 享元模式 代理模式
3.行为模式:11 种
模板方法模式 命令模式 迭代器模式 观察者模式 中介者模式 备忘录模式 解释器模式 状态模式 策略模式 职责链模式 访问者模式
分类主要是为了方便记忆 突然想到了jdk 8 有 9个函数式接口 想回忆下
单例模式的实现
单例模式-饿汗模式
饿汉模式顾名思义就是非常饿,直接吃.其实关于单例模式的总结就一句话,私有构造方法,提供外部获取实例的方法
所以在类加载的时候对象已经创建好了.方法没有锁,调用效率高!
/** * @Created by xiaodao */ public class Sington01 { //类初始化时立即加载对象(没有延迟加载的优势),天然的线程安全 private static Sington01 instance = new Sington01(); private Sington01() { } public static Sington01 getInstance(){ return instance; } }
延时加载模式
public class Sington02 { /*** * 延时加载模式,在调用的时候,才会获取对像 */ private static Sington02 sington ; private Sington02() { } /** * 同步调用效率低 * @return */ public static Sington02 getInstance(){ synchronized (Sington02.class){ if(null == sington){ sington= new Sington02(); } return sington; } } }
双重检查 double-check单例模式
/** * @Created by xiaodao * 双重检索模式 */ public class Sington03 { /*** * */ private static volatile Sington03 sington ; private Sington03() { } /** * * @return */ public static Sington03 getInstance(){ if(sington !=null ){ }else{ synchronized (Sington03.class){ if(sington== null){ sington = new Sington03(); } } } return sington; } public static void main(String[] args) { Sington03 sington03 = getInstance(); Sington03 sington04 = getInstance(); System.out.println(sington03); System.out.println(sington04); } }
静态内部类 延时加载模式
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
/** * @Created by xiaodao * */ public class Sington04 { /*** * */ private static class Sington04Interior { private static Sington04 instance= new Sington04(); }; private Sington04() { } /** * * @return */ public static Sington04 getInstance(){ return Sington04Interior.instance; } public static void main(String[] args) { Sington04 sington03 = getInstance(); Sington04 sington04 = getInstance(); System.out.println(sington03); System.out.println(sington04); } }
加载类的时候外部没有static属性不会像恶汉模式一样立即加载对象
只有getInstance才会加载静态内部类.是线程安全的
兼备了并发高效和延迟加载的优势
枚举方式实现单例模式
/** * @Created by xiaodao * */ public enum Sington05 { /*** * 定义一个枚举.代表singleton的一个实例 */ INSTANCE; public void singletonOperator(){ //这个单例的功能处理 } public static void main(String[] args) { Sington05 sington05 = Sington05.INSTANCE; } }
枚举的单例,可以避免反射和反序列来破解,实现比较简单
反射跳过单例
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException { //第一次调用. // Sington06 instance = Sington06.getInstance(); // System.out.println(instance); Class<Sington06> aClass = (Class<Sington06>) Class.forName("com.xiaodao.jdk8.disign.sington.Sington06"); //获取构造器 //第二次调用. Constructor<Sington06> declaredConstructor = aClass.getDeclaredConstructor(null); declaredConstructor.setAccessible(true); Sington06 s2 = declaredConstructor.newInstance(); Sington06 s1 = declaredConstructor.newInstance(); System.out.println(s1); System.out.println(s2); //第三次. Sington06 instance = Sington06.getInstance(); System.out.println(instance); Sington06 s3 = declaredConstructor.newInstance(); }
这种方式可以跳过单例模式,需要在单例模式里加一个判断.
private Sington06() {
if(sington !=null){
throw new RuntimeException();
}
}
平时我们写项目不需要这样的判断.但是如果是写个框架的话,可能需要严谨一点,但是这也是有漏洞的,如果你没有创建过一次单例,那么通过反射就是无数次调用,如果你创建了.那么就不能通过反射就创建了.
反序列化破解与防止反序列破解
Sington06 instance = Sington06.getInstance(); System.out.println(instance); FileOutputStream out = new FileOutputStream("/Users/xuyuanfang/study/java视频/disgin/a.txt"); ObjectOutputStream objectOutputStream = new ObjectOutputStream(out); objectOutputStream.writeObject(instance); out.close(); objectOutputStream.close(); //反序列化 ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("/Users/xuyuanfang/study/java视频/disgin/a.txt")); Sington06 s3 = (Sington06) objectInputStream.readObject(); System.out.println(s3); 防止破解: /** * 反序列化 如果定义了readResolve方法 直接调用这个方法返回对象,不需要重新创建对象 * @return */ public Object readResolve() throws ObjectStreamException { return sington; }
效率对比
恶汉模式,比懒汉方式在多线程环境下效率好点
如何选用呢?
如果对象占用资源少,不需要延时加载
枚举比恶汉式比较好
如果对象资源占用比较大的话.需要延时加载
静态内部类好于懒汉式