设计模式

1.七大原则

1.单一职责原则

（每个类或者每个方法只需要实现一个职责，不需要实现很多其他的功能。）在类中的方法足够多需要在类的层面遵守单一职责原则

方法遵循单一职责代码实现：

package com.example;

public class SingleResponsibility {
    public static void main(String[] args) {
        Vehicle vehicle = new Vehicle();
        vehicle.runAir("飞机");
        vehicle.runRolad("车子");
        vehicle.runWater("游艇");
     
    }
}
class Vehicle{
    public void runRolad(String vehicle){
        System.out.println(vehicle + "在公路上面运行");

    }
    public void runWater(String vehicle){
        System.out.println(vehicle + "在水中上面运行");
    }

    public void runAir(String vehicle){
        System.out.println(vehicle + "在天上运行");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

2.接口隔离原则

A通过接口B依赖于C（只要实现接口B的1，2，3方法）,D通过接口B依赖于F（只需要 实现接口B的1，4，5方法）,这样A就得实现所有的B接口的方法，D就得实现所有的B接口方法，导致浪费，且相关性强，所以得遵循接口最小原则，把 方法1 放在一个接口Interface1， 方法 2，3放在一个接口Interface2 ,方法4，5放在一个接口Interface3.

3.依赖倒转原则

1. 高层模块不应该依赖低层模块，二者应该依赖其抽象（接口和抽象类）
2. 抽象不应该依赖细节，细节（一般是java的实现类）应该依赖抽象
3. 、依赖倒转的中心思想是面向接口编程
4. 设计理念：以抽象为基础搭建的架构比以细节为基础的架构要稳定的多。
5. java里面接口或者抽象类的目的是设计好规范（不去实现），实现一定是由那个实现类去操作。
6. 继承时遵循里氏替换原则

代码实现

有问题代码

package com.monkey.single.inversion;

public class DependenceInversion {
    public static void main(String[] args) {
        Person person = new Person();
        person.receiveMessage(new Email());

    }
}

class Email{
    public String getInfo(){
        return "email,helloWorld";
    }
}

//1.这个只可以接收邮箱的消息，不可以接收其他的比如微信，支付宝，短信的消息。
//2.我们可以来创建一个接口IReceiver(),这样Person类和接口IReceiver发生依赖
//因为Email,WeChat等等属于接收的范围，他们各自实现IReceiver接口就行，这样就发生了依赖倒转。




class Person{
//   这里是对实现类进行了依赖
    public void receiveMessage(Email email){
        System.out.println(email.getInfo());
    }


}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

实现依赖倒转原则以后的代码

package com.monkey.single.inversion;

public class DependenceInversion {
    public static void main(String[] args) {
        Person person = new Person();
        person.receiveMessage(new Email());
        person.receiveMessage(new Wexin());

    }
}


interface Ireceiver{
    public String getInfo();
}


class Email implements Ireceiver{
    public String getInfo(){
        return "email,helloWorld";
    }
}

class Wexin implements Ireceiver{
    public String getInfo(){
        return "wexin,helloWorld";
    }

}

//1.这个只可以接收邮箱的消息，不可以接收其他的比如微信，支付宝，短信的消息。
//2.我们可以来创建一个接口IReceiver(),这样Person类和接口IReceiver发生依赖
//因为Email,WeChat等等属于接收的范围，他们各自实现IReceiver接口就行，这样就发生了依赖倒转。




class Person{

//    这里是对接口进行依赖，稳定性好
    public void receiveMessage(Ireceiver ireceiver){
        System.out.println(ireceiver.getInfo());
    }


}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

实现接口间依赖传递的三种方式：

1. 通过接口传递实现依赖
2. 通过构造方法依赖传递
3. 通过setter方法依赖传递

代码：

1

4.里氏替换原则

5.开闭原则

6.迪米特法原则

7.合成复用原则

经典面试题目？

1. 在项目的实际开发中哪里使用了ocp原则？ （工厂模式中有用）

2. spring中应用了哪些设计模式，原型模式在哪里 用到？

3. 什么是解释器设计模式？画出它的UML类图，分析各个角色是什么？

4. spring框架中哪里使用到了解释器设计模式？并做源码级别分析

5. 单例模式一共有几种实现方式？用代码实现，并说明各个的优点缺点。

单列设计模式有几种实现方式？

1. 饿汉式 两种

2. 懒汉式 三种

3. 双重检查

4. 静态内部类

   设计模式概念：（design pattern）是对在软件设计普遍存在（反复出现）的各种问题，提出 的一种解决方案。

使用设计模式可以使用项目具有：可扩展性，维护性，可靠性（新增一个功能对原来的功能影响不大），可复用性，效率提高等等