面试知识点梳理及相关面试题（七）-- 设计模式

单例模式：

• 可以用双检索、枚举、匿名内部类实现。
• 分为懒汉式（延迟加载，需要再创建）和饿汉式（一开始就创建好）。
• 由JVM保证static修饰的内容，堆中只有一份
• 枚举：避免通过反序列化来创建多个对象
  • JVM保证枚举实例的唯一性
  • 反编译可以看出来枚举其实就是一个集成了Enum的类
  • 枚举序列化是由jvm保证的，每一个枚举类型和定义的枚举变量在JVM中都是唯一的

代理模式：

为一个对象提供一个替身，以控制对这个对象的访问。即通过代理对象访问目标对象。这样做的好处是：可以在目标对象实现的基础上，增强额外的功能能操作，即扩展目标对象的功能。
实现方式：

• Cglib代理：实际上是生成一个被代理对象的子类，所以被代理对象不能被final修饰
• jdk代理：被代理对象需要实现一个接口

动态代理（jdk代理）

主要方法：newProxyInstance

/**
 * 说明：
 *      public static Object newProxyInstance(ClassLoader loader,
 *                                           Class<?>[] interfaces,
 *                                           InvocationHandler h)
 *      1. ClassLoader loader：
 *          指定当前目标对象使用的类加载器，获取加载器的方法固定
 *      2. Class<?>[] interfaces
 *          目标对象实现的接口类型，使用泛型方法确认类型
 *      3. InvocationHandler h
 *          事情处理，执行目标对象的方法时，会触发事情处理器方法，会把当前执行的目标对象方法作为参数传入
 *
 */
return Proxy.newProxyInstance(target.getClass().getClassLoader(),
        target.getClass().getInterfaces(), new InvocationHandler() {

Cglib代理：

需要实现MethodInterceptor 接口，并重写其中intercept方法。

public class CglibProxyFactory implements MethodInterceptor {
    // 维护一个目标对象
    private Object target;

    // 构造器，传入一个被代理对象
    public CglibProxyFactory (Object target) {
        this.target = target;
    }

    // 返回一个代理对象，是target对象的代理对象
    public Object getProxyInstance() {
        // 1.创建一个工具类
        Enhancer enhancer = new Enhancer();
        // 2. 设置父类
        enhancer.setSuperclass(target.getClass());
        // 3.设置回调函数
        enhancer.setCallback(this);
        // 4.创建子类对象，即代理对象
        return enhancer.create();
    }

    // 重写intercept犯法，会调用目标对象的方法
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("Cglib代理对象模式开始。。。。。。。");
        Object res = method.invoke(target, objects);
        System.out.println("Cglib代理对象模式结束。。。。。。。");
        return res;
    }
}

装饰模式：

动态的将新功能附加到对象上。
装饰模式的实现方式：装饰者中存放一个被装饰对象的引用（属性）。

1. 接口A，
2. 被装饰对象：一个实现类B，即被装饰对象。
3. 装饰者抽象类：装饰者抽象类C实现A，并在其中存放一个A的引用。
4. 具体装饰类：具体的装饰者实现类D继承C，完成对被装饰对象的装饰。

在IO中被广泛使用：

1. InputStream是抽象类
2. ByteArrayInputStream、FileInputStream、ObjectInputStream、PipedInputStream都是具体构建角色，是InputStream的子类是被装饰对象
   如FileInputStream的声明

public
class FileInputStream extends InputStream
{

3. FilterInputStream无疑就是一个装饰角色，因为FilterInputStream实现了InputStream内的所有抽象方法并且持有一个InputStream的引用

public
class FilterInputStream extends InputStream {
    /**
     * The input stream to be filtered.
     */
    protected volatile InputStream in;

    protected FilterInputStream(InputStream in) {
        this.in = in;
    }

4. 具体装饰角色就是InflaterInputStream、BufferedInputStream、DataInputStream；

享元模式：

简单点说，其实就是共享对象，避免资源的浪费。

经典使用场景就是stirng常量池，数据库连接池、缓冲池等

策略模式：

策略模式是对算法的包装，是把使用算法的责任和算法本身分开。策略模式通常是把一系列的算法包装到一系列的策略类里面，作为一个抽象策略类的子类。

策略模式涉及到三个角色：

1. 环境角色（使用者Context）：持有一个策略Strategy的引用
2. 抽象策略角色：这是一个抽象角色，通常由一个接口或抽象类实现，此角色给出所有具体策略类所需的接口
3. 具体策略角色：实现了抽象策略角色，包装了相关算法或行为

策略模式的使用：

举一个实际例子吧。假如有一个购物系统，在用户付款的时候，会产生很多场景，根据用户的不同情况算出不同用户要付款的金额，这时候最直观的一种做法是：

在付款的里面写N多的if…else if…else，判断用户的场景，根据场景计算用户付款金额。

这种设计明显违反了开闭原则。开闭原则的"闭"，指的是对修改关闭，但是这里假如算法又多了几种，那么必须再次修改这个付款的类。

这时候就可以使用策略模式。在付款的类里面持有一个付款接口的引用，每次根据不同场景传入一个具体的策略就好了。比如A类中要使用S0算法，就传入一个S0策略；B类中要使用S1算法，就传入一个S1算法。不需要把判断都放在付款的类中，代码的可读性、可维护性也更高了。付款这个类甚至可以直接生成一个.class文件放在一个jar包里面供调用。

Java中的应用：Comparator策略接口

public static void main(String[] args) {
    Integer[] data = {4,3,5,9,2};

    /**
     * 1.匿名内部类实现了Comparator接口（策略接口），匿名类对象即new Comparator<Integer>() {}
     * 2.匿名类对象中的compare方法其实就是具体的策略方法，可以指定不同的处理方式
     */
    Comparator<Integer> comparator = new Comparator<Integer>() {
        @Override
        public int compare(Integer o1, Integer o2) {
            if (o1 > o2) {
                return 1;
            } else {
                return -1;
            }
        }
    };
    // 第二个参数相当于持有一个策略的引用
    Arrays.sort(data, comparator);
    System.out.println(data);
}