项目介绍
- 本项目通过分解各大厂的常见笔面试题，追本溯源至数据结构和算法的底层实现原理，知其然知其所以然；
- 建立知识结构体系，方便查找，欢迎更多志同道合的朋友加入项目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、Builder 构造器设计模式
- 12、更多的设计模式，请直接去我的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 访问者模式
6、Factory 工厂模式
7、Delegate 委派模式
8、Prototype 原型模式
9、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 适配器模式
11、Builder 构造器设计模式
-
设计思路：
- 通过类的内部类完成对当前类的操作。
- 当前类必须有一个包含内部类的构造方法。
- 内部类的生成方法必须可以生成一个当前类的对象。
- 每次设置内部类的属性方法，必须返回当前内部类。
-
当前类的构造方法
public Student(Builder builder) {
this.age = builder.age;
this.name = builder.name;
this.address = builder.address;
this.classname = builder.classname;
}
- 内部类的生成方法
public Student build() {
return new Student(this);
}
- 设置内部类的属性方法，返回当前内部类
public Builder setaaddress(String var) {
this.address = var;
return this;
}
- 注意事项：
517
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
