设计模式

一共23种：重点：单例模式，代理模式，工厂模式

1.代理模式：（原有的对象需要额外的功能，想想动态代理这项技术！）

参考：https://blog.csdn.net/wangqyoho/article/details/77584832

当前对象不愿意干的，没法干的东西委托给别的对象来做

静态代理和动态代理 (静态代理事先知道要代理的是什么，而动态代理不知道要代理什么东西，只有在运行时才知道)

静态代理:扩展原功能，不侵入原代码,但是有很多方法的话，一一实现就会比较麻烦

动态代理：动态地在内存中构建代理对象，会默认实现接口的全部方法。

区别:

静态代理需要自己写代理类-->代理类需要实现与目标对象相同的接口
而动态代理不需要自己编写代理类--->(是动态生成的)

动态代理分为：JDK，Cglib

JDK动态代理：基于反射，加载快，spring事务使用

Cglib动态代理：基于字节码文件，调用快，AOP核心

2.包装模式（装饰模式）：

参考：https://segmentfault.com/a/1190000014771830

实现对象增强有三种方式：继承，包装模式，代理模式

一个接口类，一个实现接口的抽象装饰类，一个继承装饰类的实体类

优点：

装饰类和被装饰类是可以独立的，低耦合的。互相都不用知道对方的存在
装饰模式是继承的一种替代方案，无论包装多少层，返回的对象都是is-a的关系(上面的例子：包装完还是Phone类型)。
实现动态扩展，只要继承了装饰器就可以动态扩展想要的功能了。

缺点：

多层装饰是比较复杂的，提高了系统的复杂度。不利于我们调试~

3.单例模式

一个类中能创建一个实例，所以称之为单例。

编写单例模式的代码分了三步：

将构造函数私有化
在类的内部创建实例
提供获取唯一实例的方法

共有五种方式如下：

（1）饿汉式

 // 1.将构造函数私有化，不可以通过new的方式来创建对象
    private Java3y(){}
    // 2.在类的内部创建自行实例
    private static Java3y java3y = new Java3y();
    // 3.提供获取唯一实例的方法
    public static Student getJava3y() {
        return java3y;
    }

（2）简单懒汉式

// 1.将构造函数私有化，不可以通过new的方式来创建对象
    private Java3y(){}
    // 2.1先不创建对象，等用到的时候再创建
    private static Java3y java3y = null;

    // 2.1调用到这个方法了，证明是要被用到的了
    public static Java3y getJava3y() {
        // 3. 如果这个对象引用为null，我们就创建并返回出去
        if (java3y == null) {
            java3y = new Java3y();
        }
       return java3y;
    }

（3）DCL懒汉式（双重安全的懒汉式）

例：

private Java3y() {}
    private static volatile Java3y java3y = null;
    public static Java3y getJava3y() {
        if (java3y == null) {
            // 将锁的范围缩小，提高性能
            synchronized (Java3y.class) {
                // 再判断一次是否为null
                if (java3y == null) {
                    java3y = new Java3y();
                }
            }
        }
        return java3y;
    }

（4）静态内部类懒汉式

原理：当任何一个线程第一次调用getInstance()时，都会使SingletonHolder被加载和被初始化，此时静态初始化器将执行Singleton的初始化操作。(被调用时才进行初始化！)

初始化静态数据时，Java提供了的线程安全性保证。(所以不需要任何的同步）

  private Java3y() {
    }
    // 使用内部类的方式来实现懒加载
    private static class LazyHolder {
        // 创建单例对象
        private static final Java3y INSTANCE = new Java3y();
    }
    // 获取对象
    public static final Java3y getInstance() {
        return LazyHolder.INSTANCE;
    }

（5）枚举方式实现

例如：结果为 1、2、2 (只初始化了一次该对象)

public enum model {
Instance;
private model(){
System.out.println("1");
}
public void pr(){
System.out.println("2");
}
public static void main(String[] args) {
model m=model.Instance;
model m1=model.Instance;
m.pr();
m1.pr();
}
}

4.工厂模式：（主要就是解耦作用）

参考：https://segmentfault.com/a/1190000014949595

工厂接口

不需要知道怎么内部组装的，代替New 的作用

工厂模式分为三类：

简单/静态工厂模式
工厂方法模式
抽象工厂模式

（1）工厂方法模式

优点:

1:客户端不需要在负责对象的创建,明确了各个类的职责
2:如果有新的对象增加,只需要增加一个具体的类和具体的工厂类即可
3:不会影响已有的代码,后期维护容易,增强系统的扩展性

缺点:

需要额外的编写代码,增加了工作量

（2）简单/静态工厂模式

缺点：当需求改变了,我就要改代码.

优点：我就一个具体的工厂来创建对象，代码量少

（3）抽象工厂模式

5.策略模式

优点：

算法可以自由切换
- 改一下策略很方便
扩展性良好
- 增加一个策略，就多增加一个类就好了。

缺点：

策略类的数量增多
- 每一个策略都是一个类，复用的可能性很小、类数量增多
所有的策略类都需要对外暴露
- 上层模块必须知道有哪些策略，然后才能决定使用哪一个策略

6.门面模式

https://segmentfault.com/a/1190000017568892

优点：

减少系统的相互依赖。使用门面模式，所有的依赖都是对门面对象的依赖，与子系统无关
提高了灵活性。不管子系统内部如何变化，只要不影响门面对象，任你自由活动。

缺点：

不符合开闭原则，对修改关闭，对扩展开放。比如我们上面的例子，如果有新电器要想要加入一次关闭的队伍中，只能在门面对象上修改 turnOffAll()方法的代码。

7.模板方法

要点：

把公共的代码抽取出来，如果该功能是不确定的，那我们将其修饰成抽象方法。
将几个固定步骤的功能封装到一个方法中，对外暴露这个方法，就可以非常方便调用了。

优点：

封装不变的部分，扩展可变的部分。把认为是不变的部分的算法封装到父类，可变部分的交由子类来实现！
提取公共部分的代码，行为由父类控制，子类实现！

缺点：

抽象类定义了部分抽象方法，这些抽象的方法由子类来实现，子类执行的结果影响了父类的结果(子类对父类产生了影响)，会带来阅读代码的难度！

posted @ 2019-02-25 18:35 StingLon 阅读(121) 评论(0) 收藏举报

刷新页面返回顶部

StingLon