Skip to content

Commit cbe33c2

Browse files
author
haolin3
committed
init 设计模式
1 parent dd4f415 commit cbe33c2

25 files changed

+3406
-0
lines changed

‎专栏/设计模式/中介者模式.md

Lines changed: 185 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,185 @@
1+
## 中介者（Mediator）
2+
3+
### 介绍
4+
5+
中介者模式（Mediator Pattern）是用来降低多个对象和类之间的通信复杂性。这种模式提供了一个中介类，该类通常处理不同类之间的通信，并支持松耦合，使代码易于维护。中介者模式属于行为型模式。
6+
7+
### Intent
8+
9+
集中相关对象之间复杂的沟通和控制方式。
10+
11+
### Class Diagram
12+
13+
- Mediator：中介者，定义一个接口用于与各同事（Colleague）对象通信。
14+
- Colleague：同事，相关对象
15+
16+
<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/30d6e95c-2e3c-4d32-bf4f-68128a70bc05.png"/> </div><br>
17+
18+
### Implementation
19+
20+
Alarm（闹钟）、CoffeePot（咖啡壶）、Calendar（日历）、Sprinkler（喷头）是一组相关的对象，在某个对象的事件产生时需要去操作其它对象，形成了下面这种依赖结构：
21+
22+
<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/82cfda3b-b53b-4c89-9fdb-26dd2db0cd02.jpg"/> </div><br>
23+
24+
使用中介者模式可以将复杂的依赖结构变成星形结构：
25+
26+
<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/5359cbf5-5a79-4874-9b17-f23c53c2cb80.jpg"/> </div><br>
27+
28+
```java
29+
public abstract class Colleague {
30+
public abstract void onEvent(Mediator mediator);
31+
}
32+
```
33+
34+
```java
35+
public class Alarm extends Colleague {
36+
37+
@Override
38+
public void onEvent(Mediator mediator) {
39+
mediator.doEvent("alarm");
40+
}
41+
42+
public void doAlarm() {
43+
System.out.println("doAlarm()");
44+
}
45+
}
46+
```
47+
48+
```java
49+
public class CoffeePot extends Colleague {
50+
@Override
51+
public void onEvent(Mediator mediator) {
52+
mediator.doEvent("coffeePot");
53+
}
54+
55+
public void doCoffeePot() {
56+
System.out.println("doCoffeePot()");
57+
}
58+
}
59+
```
60+
61+
```java
62+
public class Calender extends Colleague {
63+
@Override
64+
public void onEvent(Mediator mediator) {
65+
mediator.doEvent("calender");
66+
}
67+
68+
public void doCalender() {
69+
System.out.println("doCalender()");
70+
}
71+
}
72+
```
73+
74+
```java
75+
public class Sprinkler extends Colleague {
76+
@Override
77+
public void onEvent(Mediator mediator) {
78+
mediator.doEvent("sprinkler");
79+
}
80+
81+
public void doSprinkler() {
82+
System.out.println("doSprinkler()");
83+
}
84+
}
85+
```
86+
87+
```java
88+
public abstract class Mediator {
89+
public abstract void doEvent(String eventType);
90+
}
91+
```
92+
93+
```java
94+
public class ConcreteMediator extends Mediator {
95+
private Alarm alarm;
96+
private CoffeePot coffeePot;
97+
private Calender calender;
98+
private Sprinkler sprinkler;
99+
100+
public ConcreteMediator(Alarm alarm, CoffeePot coffeePot, Calender calender, Sprinkler sprinkler) {
101+
this.alarm = alarm;
102+
this.coffeePot = coffeePot;
103+
this.calender = calender;
104+
this.sprinkler = sprinkler;
105+
}
106+
107+
@Override
108+
public void doEvent(String eventType) {
109+
switch (eventType) {
110+
case "alarm":
111+
doAlarmEvent();
112+
break;
113+
case "coffeePot":
114+
doCoffeePotEvent();
115+
break;
116+
case "calender":
117+
doCalenderEvent();
118+
break;
119+
default:
120+
doSprinklerEvent();
121+
}
122+
}
123+
124+
public void doAlarmEvent() {
125+
alarm.doAlarm();
126+
coffeePot.doCoffeePot();
127+
calender.doCalender();
128+
sprinkler.doSprinkler();
129+
}
130+
131+
public void doCoffeePotEvent() {
132+
// ...
133+
}
134+
135+
public void doCalenderEvent() {
136+
// ...
137+
}
138+
139+
public void doSprinklerEvent() {
140+
// ...
141+
}
142+
}
143+
```
144+
145+
```java
146+
public class Client {
147+
public static void main(String[] args) {
148+
Alarm alarm = new Alarm();
149+
CoffeePot coffeePot = new CoffeePot();
150+
Calender calender = new Calender();
151+
Sprinkler sprinkler = new Sprinkler();
152+
Mediator mediator = new ConcreteMediator(alarm, coffeePot, calender, sprinkler);
153+
// 闹钟事件到达，调用中介者就可以操作相关对象
154+
alarm.onEvent(mediator);
155+
}
156+
}
157+
```
158+
159+
```java
160+
doAlarm()
161+
doCoffeePot()
162+
doCalender()
163+
doSprinkler()
164+
```
165+
166+
### JDK
167+
168+
- All scheduleXXX() methods of [java.util.Timer](http://docs.oracle.com/javase/8/docs/api/java/util/Timer.html)
169+
- [java.util.concurrent.Executor#execute()](http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/Executor.html#execute-java.lang.Runnable-)
170+
- submit() and invokeXXX() methods of [java.util.concurrent.ExecutorService](http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/ExecutorService.html)
171+
- scheduleXXX() methods of [java.util.concurrent.ScheduledExecutorService](http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/ScheduledExecutorService.html)
172+
- [java.lang.reflect.Method#invoke()](http://docs.oracle.com/javase/8/docs/api/java/lang/reflect/Method.html#invoke-java.lang.Object-java.lang.Object...-)
173+
174+
你可以通过下方扫码回复【进群】，加入我们的高端计算机学习群！以及下载超过 100 张高清思维导图！
175+
176+
<div align="center">
177+
<a href="https://www.geekxh.com/code.png" style="box-shadow: rgb(210, 210, 210) 0em 0em 0.5em 0px; font-size: 17px;"><img src="https://www.geekxh.com/code.png" width="250px"></a>
178+
</div>
179+
180+
181+
182+
183+
184+
185+

‎专栏/设计模式/享元模式.md

Lines changed: 102 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,102 @@
1+
## 享元（Flyweight）
2+
3+
### 介绍
4+
5+
享元模式（Flyweight Pattern）主要用于减少创建对象的数量，以减少内存占用和提高性能。这种类型的设计模式属于结构型模式，它提供了减少对象数量从而改善应用所需的对象结构的方式。
6+
7+
享元模式尝试重用现有的同类对象，如果未找到匹配的对象，则创建新对象。我们将通过创建 5 个对象来画出 20 个分布于不同位置的圆来演示这种模式。由于只有 5 种可用的颜色，所以 color 属性被用来检查现有的 Circle 对象。
8+
9+
### Intent
10+
11+
利用共享的方式来支持大量细粒度的对象，这些对象一部分内部状态是相同的。
12+
13+
### Class Diagram
14+
15+
- Flyweight：享元对象
16+
- IntrinsicState：内部状态，享元对象共享内部状态
17+
- ExtrinsicState：外部状态，每个享元对象的外部状态不同
18+
19+
<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/5f5c22d5-9c0e-49e1-b5b0-6cc7032724d4.png"/> </div><br>
20+
21+
### Implementation
22+
23+
```java
24+
public interface Flyweight {
25+
void doOperation(String extrinsicState);
26+
}
27+
```
28+
29+
```java
30+
public class ConcreteFlyweight implements Flyweight {
31+
32+
private String intrinsicState;
33+
34+
public ConcreteFlyweight(String intrinsicState) {
35+
this.intrinsicState = intrinsicState;
36+
}
37+
38+
@Override
39+
public void doOperation(String extrinsicState) {
40+
System.out.println("Object address: " + System.identityHashCode(this));
41+
System.out.println("IntrinsicState: " + intrinsicState);
42+
System.out.println("ExtrinsicState: " + extrinsicState);
43+
}
44+
}
45+
```
46+
47+
```java
48+
public class FlyweightFactory {
49+
50+
private HashMap<String, Flyweight> flyweights = new HashMap<>();
51+
52+
Flyweight getFlyweight(String intrinsicState) {
53+
if (!flyweights.containsKey(intrinsicState)) {
54+
Flyweight flyweight = new ConcreteFlyweight(intrinsicState);
55+
flyweights.put(intrinsicState, flyweight);
56+
}
57+
return flyweights.get(intrinsicState);
58+
}
59+
}
60+
```
61+
62+
```java
63+
public class Client {
64+
65+
public static void main(String[] args) {
66+
FlyweightFactory factory = new FlyweightFactory();
67+
Flyweight flyweight1 = factory.getFlyweight("aa");
68+
Flyweight flyweight2 = factory.getFlyweight("aa");
69+
flyweight1.doOperation("x");
70+
flyweight2.doOperation("y");
71+
}
72+
}
73+
```
74+
75+
```html
76+
Object address: 1163157884
77+
IntrinsicState: aa
78+
ExtrinsicState: x
79+
Object address: 1163157884
80+
IntrinsicState: aa
81+
ExtrinsicState: y
82+
```
83+
84+
### JDK
85+
86+
Java 利用缓存来加速大量小对象的访问时间。
87+
88+
- java.lang.Integer#valueOf(int)
89+
- java.lang.Boolean#valueOf(boolean)
90+
- java.lang.Byte#valueOf(byte)
91+
- java.lang.Character#valueOf(char)
92+
93+
你可以通过下方扫码回复【进群】，加入我们的高端计算机学习群！以及下载超过 100 张高清思维导图！
94+
95+
<div align="center">
96+
<a href="https://www.geekxh.com/code.png" style="box-shadow: rgb(210, 210, 210) 0em 0em 0.5em 0px; font-size: 17px;"><img src="https://www.geekxh.com/code.png" width="250px"></a>
97+
</div>
98+
99+
100+
101+
102+

0 commit comments

Comments
 (0)