设计模式面试

1.单例设计模式

使用设计模式为了代码复用，增加可维护性。

设计模式的六大原则：开闭原则、里氏代换原则、依赖倒转原则、接口隔离原则、迪米特法则（最少知道原则）、合成/聚合复用原则

Singleton（创建）：保证一个类仅有一个实例，并提供一个访问它的全局访问点。如打印机

饿汉式单例模式

1//饿汉模式：线程安全，耗费资源。
2public class HugerSingletonTest {
3    //该对象的引用不可修改。还可以将对象的创建放到静态代码块中。
4    private static final HugerSingletonTest ourInstance = new HugerSingletonTest();
5
6    public static HugerSingletonTest getInstance() {
7        return ourInstance;
8    }
9    private HugerSingletonTest() {
10    }
11}

懒汉式：非线程安全

1public class Singleton {
2    private static Singleton ourInstance;
3
4    public static Singleton getInstance() {
5        if (null == ourInstance) {
6            ourInstance = new Singleton();
7        }
8        return ourInstance;
9    }
10    private Singleton() {
11    }
12}

懒汉式，线程安全：给方法加锁，消耗资源。

1public class Singleton {
2    private static Singleton ourInstance;
3
4    public synchronized static Singleton getInstance() {
5        if (null == ourInstance) {
6            ourInstance = new Singleton();
7        }
8        return ourInstance;
9    }
10    private Singleton() {
11    }
12}

懒汉式，线程安全：双重检查锁。

1public class Singleton {
2    private static Singleton ourInstance;
3
4    public synchronized static Singleton getInstance() {
5        if (null == ourInstance) {
6            synchronized (Singleton.class) {
7                if (null == ourInstance) {
8                    ourInstance = new Singleton();
9                }
10            }
11        }
12        return ourInstance;
13    }
14    private Singleton() {
15    }
16}

分析：

JVM会进行指令重排序，原本的步骤应该是先给 singleton 分配内存，然后调用 Singleton 的构造函数来初始化成员变量，形成实例，最后将singleton对象指向分配的内存空间，但有可能步骤会打乱，就会出现实例非空但没有初始化，抛出异常。将singleton声明成 volatile ，就可以解决该问题。

懒汉式，线程安全：静态内部类

1public class Singleton {
2    private static class SingletonHodler {
3        private static Singleton ourInstance = new Singleton();
4    }
5
6    public synchronized static Singleton getInstance() {
7        return SingletonHodler.ourInstance;
8    }
9
10    private Singleton() {
11    }
12}

懒汉式，线程安全：枚举

1enum SingletonTest {  
2    INSTANCE;  
3}

单例模式在JDK8源码中的使用：Runtime.getRuntime()方法（饿汉式单例模式）

2.适配器设计模式

适配器模式（结构）中的角色：目标接口（Target）：客户所期待的接口、需要适配的类（Adaptee）、适配器（Adapter）。

对象适配器（采用对象组合方式实现）

1//适配器类实现了目标接口
2public class Adapter implements Target{
3    private Adaptee adaptee ;
4    public Adapter() {
5        super();
6        this.adaptee = new Adaptee();
7    }
8    @Override
9    public void getHeadset2() {
10        adaptee.getHeadset3();
11    }
12    public static void main(String args[]){
13        Target target = new Adapter();
14        //表面上调用的是2孔插座方法，但其实调用的三孔插座方法。
15        target.getHeadset2();
16    }
17}
18interface Target{
19    //两孔插座
20    void getHeadset2();
21}
22class Adaptee{
23    public void getHeadset3(){
24        System.out.println("我是三孔插座！");
25    }
26}

适配器模式在JDK源码的使用

1****
2
3Arrays.asList()，其中Arrays是目标类，内部类ArrayList是适配器类，而Objects.requireNonNull(array);需要适配的类。
4
5InputStreamReader .read()，其中Reader 是目标类，InputStreamReader是适配器类，而StreamDecoder 是需要适配的类。

3.模板方法设计模式

模板方法设计模式（行为）使用了继承机制，在抽象类中定义一个模板方法，该方法引用了若干个抽象方法（由子类实现）或具体方法（子类可以覆盖重写）

模板方法设计模式在JDK源码的使用:Collections.sort()、InputStream.read()等