几种常用的设计模式的笔记

发表于 | 更新于 | 评论数：
本文字数： 17k | 阅读时长 ≈ 15 分钟

面向对象的六大原则

基础 接口和抽象类区别

抽象类是可以表示一种东西的根源，是可以有成员属性和动作的。而接口则仅仅表示动作。

单一职责原则 SRP

每个类都应该有一个单一的功能，并且该功能应该由这个类完全封装起来。所有它的（这个类的）服务都应该严密的和该功能平行（功能平行，意味着没有依赖）。
——维基百科

就是一个类尽量就只有一个单一功能。
——我的理解

开闭原则 OCP

“软件中的对象（类，模块，函数等等）应该对于扩展是开放的，但是对于修改是封闭的，”这意味着一个实体是允许在不改变它的源代码的前提下变更它的行为。该特性在产品化的环境中是特别有价值的，在这种环境中，改变源代码需要代码审查，单元测试以及诸如此类的用以确保产品使用质量的过程。遵循这种原则的代码在扩展时并不发生改变，因此无需上述的过程。
——维基百科

一个程序开发完成，实现可以修改，但新增功能接口应该通过一个新的类实现。
——我的理解

里氏替换原则 LSP

派生类（子类）对象能够替换其基类（超类）对象被使用。
——维基百科

抽象。
——我的理解

依赖倒置原则 DIP

指一种特定的解耦（传统的依赖关系创建在高层次上，而具体的策略设置则应用在低层次的模块上）形式，使得高层次的模块不依赖于低层次的模块的实现细节，依赖关系被颠倒（反转），从而使得低层次模块依赖于高层次模块的需求抽象
——维基百科

方法尽量依赖于抽象，把具体实现留给抽象方法实现。
——我的理解

接口隔离原则 ISP(灵活性)

指明客户（client）应该不依赖于它不使用的方法
——维基百科

设计接口尽量细化，不要让类实现无用的抽象方法。
——我的理解

迪米特原则/最少知识原则 LOD

每个单元对于其他的单元只能拥有有限的知识：只是与当前单元紧密联系的单元；
每个单元只能和它的朋友交谈：不能和陌生单元交谈；
只和自己直接的朋友交谈。
——维基百科

尽量降低类与类之间的耦合。
——我的理解

设计模式

Builder（建造者） 模式

适用于相同方法不同执行顺序产生不同结果，或者是初始化对象参数多的时候。
代码

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
47
48
49
50
51
52
53
54
public  class Computer {
    private String mBoard;
    private String mOS;
    public Computer( Builder builder) {
        this.mBoard=builder.mBoard;
        this.mOS=builder.mOS;
    }
    public String getBoard() {
        return mBoard;
    }
    public void setBoard(String board) {
        mBoard = board;
    }
    @Override
    public String toString() {
        return "Computer{" +
                "mBoard='" + mBoard + '\'' +
                ", mOS='" + mOS + '\'' +
                '}';
    }
    public static class Builder{
        private String mBoard;
        private String mOS;
        public Builder setWinBoard(){
            mBoard="windows主板";
            return this;
        }
        public Builder setMacBoard(){
            mBoard="Mac主板";
            return this;
        }
        public Builder setMacOs(){
            mOS="Mac系统";
            return this;
        }
        public Builder setWindows(){
            mOS="win系统";
            return  this;
        }
        public Computer creat(){
            return new Computer(this);
        }
    }
}

效果

1
2
Computer computer=new Computer.Builder().setWinBoard().setWindows().creat();
System.out.println(computer);

Prototype（原型）模式

主要就是拷贝对象，适用于初始化对象消耗资源严重的时候，注意拷贝的对象的构造方法不会执行，且注意除了基本数据类型外是按值传递其它都是按引用传递，要注意浅克隆不会克隆引用。深克隆也可以采用对象序列化的方式。

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
47
48
49
50
51
52
53
54
55
public class Word  implements Cloneable{
    private String text;
    private int page;
    
    private ArrayList<String> name = new ArrayList<>();
    public String getText() {
        return text;
    }
    public void setText(String text) {
        this.text = text;
    }
    public int getPage() {
        return page;
    }
    public void setPage(int page) {
        this.page = page;
    }
    public List<String> getName() {
        return name;
    }
    public void setName(String name) {
        this.name.add(name);
    }
    @Override
    public String toString() {
        return "Word{" +
                "text='" + text + '\'' +
                ", page=" + page +
                ", name=" + name +
                '}';
    }
    @Override
    protected Object clone() throws CloneNotSupportedException {
        try {
            Word word = (Word) super.clone();
            word.text = this.text;
            word.page = this.page;
            word.name = (ArrayList<String>) this.name.clone();//深克隆
            return word;
        } catch (Exception e) {
        }
        return null;
    }
}

效果

1
2
3
4
5
6
7
8
9
10
11
12
Word word=new Word();
word.setName("zhangsan");
word.setPage(1);
word.setText("~~~~~~~~~~~~~~~~~~~~");
System.out.println(word);
Word word1= (Word) word.clone();//拷贝的时候不会执行构造函数
System.out.println(word1);
word.setName("lisi");
word.setPage(8);
word.setText("!!!!!!!!!!!!!!!!!!!!!");
System.out.println(word);
System.out.println(word1);

Factory（工厂）模式

用于创建对象使用，需要生成复杂的对象的时候用。

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
public abstract class Car {
    public abstract String carType();
}
public class Car1 extends Car {
    @Override
    public String carType() {
        return "老年代步车";
    }
}
public class Car2 extends Car {
    @Override
    public String carType() {
        return "跑车";
    }
}
public abstract class Factory {
    public abstract <T extends Car> T creatCar(Class<T> clz);
}
public class CarFactory extends Factory {
    @Override
    public <T extends Car> T creatCar(Class<T> clz) {
        Car car=null;
        try {
            car=(Car) Class.forName(clz.getName()).newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return (T) car;
    }
}

效果

1
2
CarFactory carFactory = new CarFactory();
Car car =carFactory.creatCar(Car1.class);

Abstract Factory（抽象工厂）模式

工厂方法模式针对的是一个产品等级结构；而抽象工厂模式针对的是多个产品等级结构。就是更抽象化的工厂模式。

Strategy（策略）模式

适用于 一种类型的多种操作方法的时候或者一个抽象类有多个子类而又需要用if else 或者 switch case来选择具体子类的时候。用来封装算法。
例子是计算不同轮胎在不同公里消耗情况

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
public interface TireStatus {
    int tireWearDegree(int km);
}
public class NormalTireStatus implements TireStatus {
    @Override
    public int tireWearDegree(int km) {
        return km;
    }
}
public class TrackTireStatus implements TireStatus {
    @Override
    public int tireWearDegree(int km) {
        return km*2;
    }
}
public class TireStatusCalculate {
    private TireStatus mTireStatus;
    public TireStatusCalculate(TireStatus tireStatus) {
        mTireStatus = tireStatus;
    }
    public int getTireWearDegree(int km){
        return mTireStatus.tireWearDegree(km);
    }
}

效果

1
2
3
4
5
6
7
8
TireStatusCalculate tireStatusCalculate = new TireStatusCalculate(new NormalTireStatus());
        tireStatusCalculate.getTireWearDegree(5);
TireStatusCalculate tireStatusCalculate1 = new TireStatusCalculate(new TrackTireStatus());
        tireStatusCalculate1.getTireWearDegree(5);
		
		//输出：5 
		//         10

State（状态）模式

适用于一个对象的行为取决于它的状态·，且需要在运行时改变状态。
这里例子用汽车关闭电源 打开电源 和启动发动机的状态

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
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
public interface CarFunction {
    void brake();//刹车
    void speedUp();//加速
    void TurnOffLight();//开灯
    void TurnOnLight();//关灯
}
public class CarPowerOff implements CarFunction {
    @Override
    public void brake() {
        System.out.println("刹车");
    }
    @Override
    public void speedUp() {
    }
    @Override
    public void TurnOffLight() {
    }
    @Override
    public void TurnOnLight() {
    }
}
public class CarPowerOn implements CarFunction {
    @Override
    public void brake() {
        System.out.println("刹车");
    }
    @Override
    public void speedUp() {
    }
    @Override
    public void TurnOffLight() {
        System.out.println("关灯");
    }
    @Override
    public void TurnOnLight() {
        System.out.println("开灯");
    }
}
public class CarStart implements CarFunction  {
    @Override
    public void brake() {
        System.out.println("刹车");
    }
    @Override
    public void speedUp() {
        System.out.println("加速");
    }
    @Override
    public void TurnOffLight() {
        System.out.println("关灯");
    }
    @Override
    public void TurnOnLight() {
        System.out.println("开灯");
    }
}
///////////////////////////////////////////////////////////////////////////////////////////////////
public interface CarPowerController {
    void carPowerOff();
    void carPowerOn();
    void carStart();
}
public class CarController implements CarPowerController  {
    private CarFunction mCarFunction;
    public void setCarFunction(CarFunction carFunction) {
        mCarFunction = carFunction;
    }
    @Override
    public void carPowerOff() {
        setCarFunction(new CarPowerOff());
    }
    @Override
    public void carPowerOn() {
        setCarFunction(new CarPowerOn());
    }
    @Override
    public void carStart() {
        setCarFunction(new CarStart());
    }
    public void brake() {
        mCarFunction.brake();
    }
    public void speedUp() {
        mCarFunction.speedUp();
    }
    public void TurnOffLight() {
        mCarFunction.TurnOffLight();
    }
    public void TurnOnLight() {
        mCarFunction.TurnOnLight();
    }
}

效果

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
CarController carController=new CarController();
carController.carPowerOff();
carController.TurnOnLight();
carController.TurnOffLight();
carController.speedUp();
carController.brake();
carController.carPowerOn();
carController.TurnOnLight();
carController.TurnOffLight();
carController.speedUp();
carController.brake();
carController.carStart();
carController.TurnOnLight();
carController.TurnOffLight();
carController.speedUp();
carController.brake();

Iterator（责任链）模式

适合于多个对象可以处理同一个请求，但具体有哪个处理则在运行时动态决定。
例子为请假审批流程

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
47
48
49
50
51
public abstract class Leader {
    public Leader nextLeader;
    
    public final void leaderRequest(int day){
        if(day>leaveDayLevel()){
            handle(day);
            if(nextLeader!=null)
            nextLeader.leaderRequest(day);
        }else {
            handle(day);
        }
    }
    protected abstract int leaveDayLevel();
    protected abstract void  handle(int day);
}
public class DepartmentManager extends Leader {
    @Override
    protected int leaveDayLevel() {
        return 3;
    }
    @Override
    protected void handle(int day) {
        System.out.println("请假"+day+"天，部门负责人签名。");
    }
}
public class GeneralManager extends Leader {
    @Override
    protected int leaveDayLevel() {
        return 5;
    }
    @Override
    protected void handle(int day) {
        System.out.println("请假"+day+"天，总经理签名。");
    }
}
public class Boss extends Leader {
    @Override
    protected int leaveDayLevel() {
        return 10;
    }
    @Override
    protected void handle(int day) {
        System.out.println("请假"+day+"天，老板签名。");
    }
}

效果

1
2
3
4
5
6
7
8
DepartmentManager departmentManager=new DepartmentManager();
GeneralManager generalManager=new GeneralManager();
Boss boss=new Boss();
departmentManager.nextLeader=generalManager;
generalManager.nextLeader=boss;
departmentManager.leaderRequest(1);
departmentManager.leaderRequest(4);
departmentManager.leaderRequest(10);

Template（模板）模式

适用于多个子类公有的方法，且逻辑基本相同时候，不改变结构通过重写部分实现内容。

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
public abstract class Noodles {
    
    public void putWater() {
        System.out.println("放水");
    }
    public void putNoodles() {
        System.out.println("放面");
    }
    public void openFire() {
        System.out.println("开火");
    }
    public void putSauce() {
        System.out.println("不放调味料");
    }
    public void closeFire() {
        System.out.println("关火");
    }
    public final void makeNoodles() {
        putWater();
        putNoodles();
        openFire();
        putSauce();
        closeFire();
    }
    
}
public class NoodleShopA extends Noodles {
    @Override
    public void putSauce() {
        System.out.println("加香肠加葱");
    }
}
public class NoodleShopB extends Noodles {
    @Override
    public void putSauce() {
       System.out.println("加鸡蛋加辣椒");
    }
}

效果

1
2
3
4
5
Noodles noodles =new NoodleShopA();
noodles.makeNoodles();
noodles=new NoodleShopB();
noodles.makeNoodles();

Composite（组合）模式

适用于需要表示对象部分或整体层次的时候

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
47
48
49
public abstract class Component {
    public String name;//节点名
    public Component(String name) {
        this.name = name;
    }
    public abstract void doSomething();
    
    public abstract void addChild(Component child);
    
    public abstract void removeChild(Component child);
    
    public abstract Component getChildren(int index);
}
public class Composite extends Component {
    private List<Component> mComponentList=new ArrayList<>();
    public Composite(String name) {
         super(name);
    }
    @Override
    public void doSomething() {
        System.out.println(name);
        if(mComponentList!=null){
            for(Component component:mComponentList){
                component.doSomething();
            }
        }
    }
    @Override
    public void addChild(Component child){
        mComponentList.add(child);
    }
    @Override
    public void removeChild(Component child){
        mComponentList.remove(child);
    }
    @Override
    public Component getChildren(int index) {
        return mComponentList.get(index);
    }
}

效果

1
2
3
4
5
6
7
8
9
Composite root = new Composite("一级");
Composite branch1 = new Composite("分支1");
Composite branch2 = new Composite("分支2");
Composite branchChild1 = new Composite("分支1子节点");
branch1.addChild(branchChild1);
root.addChild(branch1);
root.addChild(branch2);
root.doSomething();

Flyweight（享元）模式

适用于系统存在大量相似对象，可以通过享元模式进行缓存

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
public  class Machine {
    private String model;
    private String os;
    private int memory;
    public Machine(String model, String os, int memory) {
        this.model = model;
        this.os = os;
        this.memory = memory;
    }
    @Override
    public String toString() {
        return "Machine{" +
                "model='" + model + '\'' +
                ", os='" + os + '\'' +
                ", memory=" + memory +
                '}';
    }
}
public class MachineFactory {
    public static Map<String, Machine> machineMap = new ConcurrentHashMap<>();
    public static Machine getMachine(String model, String os, int memory) {
        String key = model + "-" + os + "-" + memory;
        if (machineMap.containsKey(key)) {
            Machine machine = machineMap.get(key);
            System.out.println("使用缓存机器信息" + machine);
            return machine;
        }
        Machine machine = new Machine(model, os, memory);
        System.out.println("新建机器信息" + machine);
        machineMap.put(key,machine);
        return machine;
    }
}

效果

1
2
3
Machine machine1=MachineFactory.getMachine("a1","windows",16);
Machine machine2=MachineFactory.getMachine("a2","mac",10);
Machine machine3=MachineFactory.getMachine("a1","windows",16);

Adapter（适配器）模式

适合于系统需要当前的类，而当前的类不符合需求需要转换的情况。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public interface TypeCComponent {
    void typeC();
}
public interface UsbComponent {
    void usb();
}
public class Usb implements UsbComponent {
    @Override
    public void usb() {
        System.out.println("usb输出");
    }
}
public class UsbAdapter extends Usb implements TypeCComponent {
    @Override
    public void typeC() {
        System.out.println("typec输出");
    }
}

效果

1
2
3
      UsbAdapter usbAdapter=new UsbAdapter();
      usbAdapter.typeC();
//输出：typec输出

Command（命令）模式

适用于将一个请求封装为一个对象，从而可用不同的请求对客户进行参数化；对请求排队或记录日志，以及支持可撤销的操作。就是把具体执行命令的类包装两层。

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
public class Receiver {
    public void action(){
        System.out.println("执行具体操作");
    }
}
public interface Command {
    void  execute();
}
public class ConcreteCommand implements Command {
    private Receiver mReceiver;
    public ConcreteCommand(Receiver receiver) {
        mReceiver = receiver;
    }
    @Override
    public void execute() {
        mReceiver.action();
    }
}
public class Invoker {
    private Command mCommand;
    public Invoker(Command command) {
        mCommand = command;
    }
    public void action(){
        mCommand.execute();
    }
}

效果

1
2
3
Invoker invoker=new Invoker(new ConcreteCommand(new Receiver()));
invoker.action();
//输出： 执行具体操作

Observer（观察者）模式

适用于一对多的依赖状态，使当一个类改变状态时，所有依赖它的其它类会收到通知。

Proxy（代理）模式

适用于不想直接或无法直接访问一个类的时候，可以使用代理对象。
代理模式

Singleton（单例）模式

适用于确保一个类只有一个实例的情况
懒汉式单例模式

静态内部类单例(线程安全且懒加载)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class StaticInnerSingleton {
    private StaticInnerSingleton() {
      }
    private static class SingletonHolder {
        private static StaticInnerSingleton instance = new StaticInnerSingleton();
    }
    public static StaticInnerSingleton getInstance() {
        return SingletonHolder.instance;
    }
}

Decorator（装饰）模式

动态地将责任附加到对象上.若要扩展功能,装饰者提供了比继承更有弹性的替代方案。
懒汉式单例模式