十大常见设计模式，一次性让你面试通过(gitbuh项目：AlgorithmPractice)

项目介绍

• 本项目通过分解各大厂的常见笔面试题，追本溯源至数据结构和算法的底层实现原理，知其然知其所以然；
• 建立知识结构体系，方便查找，欢迎更多志同道合的朋友加入项目AlgorithmPractice，（欢迎提issue和pull request）。

十大常见设计模式：

• 1、Singleton 单例模式
• 2、Proxy 代理模式
• 3、Strategy 策略模式
• 4、Observer 观察者模式
• 5、Visitor 访问者模式
• 6、Factory 工厂模式
• 7、Delegate 委派模式
• 8、Prototype 原型模式
• 9、Template 模板模式
• 10、Adapter 适配器模式
• 11、更多的设计模式，请直接去我的github上的设计模式板块查找，感谢你技术这么好，还来关注我！

正文开始

1、Singleton 单例模式

• 代码实现：Singleton
• 设计思路：
  • 在某些场景下，我们需要某个类仅仅只提供一个实例化对象，所以我们把该类的构造函数私有。
  • 私有之后我们如何获取该类的对象呢？我们对外提供一个getInstance函数，将私有的对象输出。
  • 那么这个私有的对象哪里来的？如果一个是在类中一开始就定义了对象，然后通过getInstance函数返回，我们称之为饿汉模式（因为太饿了，所有必须new出来食物/instance等我）。如果一开始定义，而是后面使用的时候，在getInstance函数中new，并且返回，成为懒汉模式。
  • 为什么会存在饿汉模式和懒汉模式？饿汉模式和懒汉模式的区别在于什么时候new对象，我们知道new对象是一个消耗资源和时间的过程，需要cpu来调度以及分配内存，特别是对于很大的对象，嵌套的对象，往往加载起来很慢，而如果我们在实际使用到的时候再加载，那么相对会节省时间。
  • 那么是不是只要用懒汉模式就好了？并不是，懒汉模式用的不好，会引起安全问题，及出现多个对象，违背了单例模式的初衷，进一步引起线程安全问题。
  • 那么如何用能保障安全问题呢？通过加锁synchronized来保证，但是加锁会导致性能上的损失，如果减小这方面的损失且运行安全呢？引入DCLSingletom,但是DCLSingletom就一定安全么？其实不然，因为指令重排的存在，会有一定几率导致使用该对象的时候出错（对象属性值为null）。
  • 更好的建议？使用枚举和内部累来实现单例模式。
• 注意事项：
  • 使用synchronized的时候，记得配合volatile来禁止指令重排

2、Proxy 代理模式

• 代码实现：Proxy
• 设计思路：
  • 代理模式的出现，主要是借助了开发语言的继承、重写的特性
  • 代理模式就是在真正的执行类的前后加上一些常规操作，一些大家都会用到的公共方法，常见的应用比如统一异常处理、统一日志、统一错误返回等，都是运用代理模式，让真正的执行类只关系业务本身，而不需要过度的考虑其他情况。
  • 代码展示：
• 代理接口，代理类和被代理类都需要实现它，并且复写它的方法

public interface ProxyInterface {
    
    
    void work();
}

• 代理类

public class Proxy implements ProxyInterface {
    
    
    ProxyInterface p;
    public Proxy(ProxyInterface r) {
    
    
        // TODO Auto-generated constructor stub
        p = r;
    }
    @Override
    public void work() {
    
    
        // TODO Auto-generated method stub
        System.out.println("i am Proxy, i am help real's work,work begin");
        p.work();
        System.out.println("i am Proxy, work end");
    }
}

• 真正的执行类

public class Real implements ProxyInterface {
    
    

    @Override
    public void work() {
    
    
        // TODO Auto-generated method stub
        System.out.println("i am real, i am doing work");
    }
}

• 实现效果

public class ProxyTest {
    
    

    @Test
    public void testProxy(){
    
    
        ProxyInterface r = new Real();
        ProxyInterface p = new Proxy(r);
        p.work();
    }
}

• 注意事项：
  • 在设计上，代理类需要考虑的比被代理类多一些。

3、Strategy 策略模式

• 代码实现：Strategy
• 设计思路：
  • 策略模式在本质其实跟代理模式差不多，都是包装一层后显示
  • 但是代理用的是类的重写，策略用的就真的是包装，哈哈
  • 策略用一个类当容器，来包装实际类，并且用统一的方法来调用被包装类。
  • 策略容器和策略接口没关系，代理类和代理接口有关系
  • 代码实现
• 策略接口

public interface Strategy {
    
    
    void method();
}

• 策略1

public class strategy01 implements Strategy {
    
    
    @Override
    public void method() {
    
    
        // TODO Auto-generated method stub
        System.out.println("strategy01's method.");
    }
}

• 策略2

public class strategy02 implements Strategy {
    
    
    @Override
    public void method() {
    
    
        // TODO Auto-generated method stub
        System.out.println("strategy02's method.");
    }
}

• 策略容器

public class StrategyMethod {
    
    
    Strategy strategy;
    public StrategyMethod(Strategy strategy) {
    
    
        this.strategy = strategy;
    }
    public void opera() {
    
    
        strategy.method();
    }
}

• 实际效果

public class StrategyTest {
    
    
    @Test
    public void tetsStrategy(){
    
    
        Strategy s1 = new strategy01();
        Strategy s2 = new strategy02();
        StrategyMethod sm1 = new StrategyMethod(s1);
        sm1.opera();
        StrategyMethod sm2 = new StrategyMethod(s2);
        sm2.opera();
    }
}

• 注意事项：

4、Observer 观察者模式

• 代码实现：Observer
• 设计思路：
  • 观察者模式相当于游戏里面的眼，观察者在被观察者的方法内插个眼，当被观察者的这个方法被执行时，那么观察者就会收到信息，并启动响应的方法。
  • 因此，一个完整的观察者模式包括：被观察者、观察者。
  • 被观察者应该有个方法是专门来加载观察者的，还有一个方法来通知观察者的
  • 因此观察者也应该有个回调方法，是等着观察者来触发的
  • 代码实现
• 观察者

public class ObserverDemo {
    
    
    String name;
    public ObserverDemo(String name) {
    
    
        this.name = name;
    }
    public void lister() {
    
    
        System.out.println(name + " --> 观察到异常，并采取行动");
    }
}

• 被观察者

public class ObservableDemo {
    
    
    List<ObserverDemo> list = new ArrayList<>();
    public void attach(ObserverDemo observerDemo) {
    
    
        list.add(observerDemo);
    }
    public void normalaction() {
    
    
        System.out.println("ObservableDemo normalaction:普通方法不会引起观察 ");
    }
    public void action() {
    
    
        System.out.println("ObservableDemo action：特殊方法会引起观察");
        notification();
    }
    public void notification() {
    
    
        for (ObserverDemo o : list) {
    
    
            o.lister();
        }
    }
}

• 实现效果

public class ObserverTest {
    
    
    @Test
    public void Testobserer(){
    
    

        //被观察者
        ObservableDemo observableDemo = new ObservableDemo();
        //观察者
        ObserverDemo observerDemo1 = new ObserverDemo("observerDemo1");
        ObserverDemo observerDemo2 = new ObserverDemo("observerDemo2");
        //被观察者将观察者加入自己的方法内
        observableDemo.attach(observerDemo1);
        observableDemo.attach(observerDemo2);
        //被观察者触发某个方法
        observableDemo.action();
        System.out.println("-----------------");
        observableDemo.normalaction();

    }
}

ObservableDemo action：特殊方法会引起观察
observerDemo1 --> 观察到异常，并采取行动
observerDemo2 --> 观察到异常，并采取行动
-----------------
ObservableDemo normalaction:普通方法不会引起观察 

• 注意事项：

5、Visitor 访问者模式

• 代码实现：Visitor
• 设计思路：
• 注意事项：

6、Factory 工厂模式

• 代码实现：Factory
• 设计思路：
• 注意事项：

7、Delegate 委派模式

• 代码实现：
• 设计思路：
• 注意事项：

8、Prototype 原型模式

• 代码实现：
• 设计思路：
• 注意事项：

9、Template 模板模式

• 代码实现：Template
• 设计思路：
  • 模板设计模式的本质就是固定算法框架
  • 父类固定模板，但是开放模板的具体实现步骤，允许子类重写
  • 代码实现
• 父类

public abstract class TemplateDemo {
    
    
    public final void template() {
    
    
        method1();
        method2();
        method3();
    }
    public void method1() {
    
    
        System.out.println("father class first stop");
    }
    public void method2() {
    
    
        System.out.println("father class second stop");
    }
    public void method3() {
    
    
        System.out.println("father class third stop");
    }
}

• 子类

public class SubTemplate extends TemplateDemo {
    
    
    @Override
    public void method1() {
    
    
        System.out.println("sub class first step");
    }
}

• 实现

public class TemplateTest {
    
    
    SubTemplate subTemplate = new SubTemplate();
    @Test
    public void testTemplate() {
    
    
        subTemplate.template();
    }
}

• 注意事项：
  • 一般模板设计模式会配合链式编程一起实现

10、Adapter 适配器模式

• 代码实现：Adapter
• 设计思路：
• 注意事项：