总体来说设计模式分为三大类：创建型模式、结构型模式和行为型模式。
博主的上一篇文章已经提到过创建型模式，此外该文章还有设计模式概况和设计模式的六大原则。设计模式的六大原则是设计模式的核心思想，详情请看博主的另外一篇文章： Java经典设计模式之五大创建模式（附实例和详解）。
接下来我们看看结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。其中适配器模式主要分为三类：类的适配器模式、对象的适配器模式、接口的适配器模式。其中的对象的适配器模式是各种结构型模式的起源。
一、适配器模式
适配器模式主要分为三类：类的适配器模式、对象的适配器模式、接口的适配器模式。
适配器模式将某个类的接口转换成客户端期望的另一个接口表示，目的是消除由于接口不匹配所造成的类的兼容性问题。有点抽象，我们来看看详细的内容。
1.1、类的适配器模式
类的适配器模式核心思想就是：有一个Source类，拥有一个方法，待适配，目标接口是Targetable，通过Adapter类，将Source的功能扩展到Targetable里。
1
2
3
4
5
6
7
packagecom.model.structure;
publicclass Source {
publicvoid method1() {
System.out.println("this is original method!");
}
}
1
2
3
4
5
6
7
8
9
packagecom.model.structure;
publicinterface Targetable {
/* 与原类中的方法相同 */
public void method1();
/* 新类的方法 */
publicvoid method2();
}
1
2
3
4
5
6
7
packagecom.model.structure;
publicclass Adapter extends Source implements Targetable {
publicvoid method2() {
System.out.println("this is the targetable method!");
}
}
1
2
3
4
5
6
7
8
9
packagecom.model.structure;
publicclass AdapterTest {
publicstatic void main(String[] args) {
Targetable target = new Adapter();
target.method1();
target.method2();
}
}
AdapterTest的运行结果：
.jpg)
1.2、对象的适配器模式
对象的适配器模式的基本思路和类的适配器模式相同，只是将Adapter类作修改成Wrapper，这次不继承Source类，而是持有Source类的实例，以达到解决兼容性的问题。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
packagecom.model.structure;
publicclass Wrapper implements Targetable {
privateSource source;
publicWrapper(Source source) {
super();
this.source = source;
}
@Override
publicvoid method2() {
System.out.println("this is the targetable method!");
}
@Override
publicvoid method1() {
source.method1();
}
}
1
2
3
4
5
6
7
8
9
10
packagecom.model.structure;
publicclass AdapterTest {
publicstatic void main(String[] args) {
Source source = new Source();
Targetable target = new Wrapper(source);
target.method1();
target.method2();
}
}
运行结果跟类的适配器模式例子的一样。
1.3、接口的适配器模式
接口的适配器是这样的：有时我们写的一个接口中有多个抽象方法，当我们写该接口的实现类时，必须实现该接口的所有方法，这明显有时比较浪费，因为并不是所有的方法都是我们需要的，有时只需要某一些，此处为了解决这个问题，我们引入了接口的适配器模式，借助于一个抽象类，该抽象类实现了该接口，实现了所有的方法，而我们不和原始的接口打交道，只和该抽象类取得联系，所以我们写一个类，继承该抽象类，重写我们需要的方法就行了。
这里看文字描述已经试够清楚的了，因此就不贴代码实例了。
二、装饰模式
装饰模式：在不必改变原类文件和使用继承的情况下，动态地扩展一个对象的功能。它是通过创建一个包装对象，也就是装饰来包裹真实的对象。
装饰模式的特点：
（1） 装饰对象和真实对象有相同的接口。这样客户端对象就能以和真实对象相同的方式和装饰对象交互。
（2） 装饰对象包含一个真实对象的引用（reference）
（3） 装饰对象接受所有来自客户端的请求。它把这些请求转发给真实的对象。
（4） 装饰对象可以在转发这些请求以前或以后增加一些附加功能。这样就确保了在运行时，不用修改给定对象的结构就可以在外部增加附加的功能。在面向对象的设计中，通常是通过继承来实现对给定类的功能扩展。继承不能做到这一点，继承的功能是静态的，不能动态增删。
具体看看代码实例
1
2
3
4
5
packagecom.model.structure;
publicinterface Sourceable {
publicvoid method();
}
1
2
3
4
5
6
7
8
9
packagecom.model.structure;
publicclass Source implements Sourceable {
@Override
publicvoid method() {
System.out.println("the original method!");
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
packagecom.model.structure;
publicclass Decorator implements Sourceable {
privateSourceable source;
publicDecorator(Sourceable source) {
super();
this.source = source;
}
@Override
publicvoid method() {
System.out.println("before decorator!");
source.method();
System.out.println("after decorator!");
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
packagecom.model.structure;
publicclass DecoratorTest {
publicstatic void main(String[] args) {
//（1） 装饰对象和真实对象有相同的接口。这样客户端对象就能以和真实对象相同的方式和装饰对象交互。
//（2） 装饰对象包含一个真实对象的引用（reference）
//（3） 装饰对象接受所有来自客户端的请求。它把这些请求转发给真实的对象。
//（4） 装饰对象可以在转发这些请求以前或以后增加一些附加功能。这样就确保了在运行时，不用修改给定对象的结构就可以在外部增加附加的功能。
// 在面向对象的设计中，通常是通过继承来实现对给定类的功能扩展。
// 继承不能做到这一点，继承的功能是静态的，不能动态增删。
Sourceable source = new Source();
Sourceable obj = new Decorator(source);
obj.method();
}
}
运行结果：
1
2
3
before decorator!
the original method!
after decorator!
三、代理模式
代理模式就是多一个代理类出来，替原对象进行一些操作。代理类就像中介，它比我们掌握着更多的信息。
具体看看代码实例。
1
2
3
4
5
packagecom.model.structure;
publicinterface Sourceable {
publicvoid method();
}
1
2
3
4
5
6
7
8
9
packagecom.model.structure;
publicclass Source implements Sourceable {
@Override
publicvoid method() {
System.out.println("the original method!");
}
}
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
packagecom.model.structure;
publicclass Proxy implements Sourceable {
privateSource source;
publicProxy() {
super();
this.source = new Source();
}
@Override
publicvoid method() {
before();
source.method();
atfer();
}
privatevoid atfer() {
System.out.println("after proxy!");
}
privatevoid before() {
System.out.println("before proxy!");
}
}
1
2
3
4
5
6
7
8
9
packagecom.model.structure;
publicclass ProxyTest {
publicstatic void main(String[] args) {
Sourceable source = new Proxy();
source.method();
}
}
运行结果：
1
2
3
before proxy!
the original method!
after proxy!
四、外观模式
外观模式是为了解决类与类之间的依赖关系的，像spring一样，可以将类和类之间的关系配置到配置文件中，而外观模式就是将他们的关系放在一个Facade类中，降低了类类之间的耦合度，该模式中没有涉及到接口。
我们以一个计算机的启动过程为例，看看如下的代码：
1
2
3
4
5
6
7
8
9
10
11
12
packagecom.model.structure;
publicclass CPU {
publicvoid startup() {
System.out.println("cpu startup!");
}
publicvoid shutdown() {
System.out.println("cpu shutdown!");
}
}
1
2
3
4
5
6
7
8
9
10
11
12
packagecom.model.structure;
publicclass Disk {
publicvoid startup() {
System.out.println("disk startup!");
}
publicvoid shutdown() {
System.out.println("disk shutdown!");
}
}
1
2
3
4
5
6
7
8
9
10
11
12
packagecom.model.structure;
publicclass Memory {
publicvoid startup() {
System.out.println("memory startup!");
}
publicvoid shutdown() {
System.out.println("memory shutdown!");
}
}
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
packagecom.model.structure;
publicclass Computer {
privateCPU cpu;
privateMemory memory;
privateDisk disk;
publicComputer() {
cpu = new CPU();
memory = new Memory();
disk = new Disk();
}
publicvoid startup() {
System.out.println("start the computer!");
cpu.startup();
memory.startup();
disk.startup();
System.out.println("start computer finished!");
}
publicvoid shutdown() {
System.out.println("begin to close the computer!");
cpu.shutdown();
memory.shutdown();
disk.shutdown();
System.out.println("computer closed!");
}
}
1
2
3
4
5
6
7
8
9
10
packagecom.model.structure;
publicclass User {
publicstatic void main(String[] args) {
Computer computer = new Computer();
computer.startup();
computer.shutdown();
}
}
运行结果：
1
2
3
4
5
6
7
8
9
10
start the computer!
cpu startup!
memory startup!
disk startup!
start computer finished!
begin to close the computer!
cpu shutdown!
memory shutdown!
disk shutdown!
computer closed!
五、桥接模式
在软件系统中，某些类型由于自身的逻辑，它具有两个或多个维度的变化，那么如何应对这种“多维度的变化”？如何利用面向对象的技术来使得该类型能够轻松的沿着多个方向进行变化，而又不引入额外的复杂度？这就要使用Bridge模式。
在提出桥梁模式的时候指出，桥梁模式的用意是”将抽象化(Abstraction)与实现化(Implementation)脱耦，使得二者可以独立地变化”。这句话有三个关键词，也就是抽象化、实现化和脱耦。
抽象化：存在于多个实体中的共同的概念性联系，就是抽象化。作为一个过程，抽象化就是忽略一些信息，从而把不同的实体当做同样的实体对待。
实现化：抽象化给出的具体实现，就是实现化。
脱耦：所谓耦合，就是两个实体的行为的某种强关联。而将它们的强关联去掉，就是耦合的解脱，或称脱耦。在这里，脱耦是指将抽象化和实现化之间的耦合解脱开，或者说是将它们之间的强关联改换成弱关联。
下面我们来看看代码实例：
1
2
3
4
5
packagecom.model.structure;
publicinterface Driver {
publicvoid connect();
}
1
2
3
4
5
6
7
8
9
packagecom.model.structure;
publicclass MysqlDriver implements Driver {
@Override
publicvoid connect() {
System.out.println("connect mysql done!");
}
}
1
2
3
4
5
6
7
8
9
packagecom.model.structure;
publicclass DB2Driver implements Driver {
@Override
publicvoid connect() {
System.out.println("connect db2 done!");
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
packagecom.model.structure;
publicabstract class DriverManager {
privateDriver driver;
publicvoid connect() {
driver.connect();
}
publicDriver getDriver() {
returndriver;
}
publicvoid setDriver(Driver driver) {
this.driver = driver;
}
}
1
2
3
4
5
6
7
8
9
packagecom.model.structure;
publicclass MyDriverManager extends DriverManager {
publicvoid connect() {
super.connect();
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
packagecom.model.structure;
publicclass Client {
publicstatic void main(String[] args) {
DriverManager driverManager = new MyDriverManager();
Driver driver1 = new MysqlDriver();
driverManager.setDriver(driver1);
driverManager.connect();
Driver driver2 = new DB2Driver();
driverManager.setDriver(driver2);
driverManager.connect();
}
}
执行结果：
1
2
connect mysql done!
connect db2 done!
如果看完代码实例还不是很理解，我们想想如下两个维度扩展：（1）假设我想加一个OracleDriver，这是一个维度，很好理解，不多解释。（2）假设我们想在连接前后固定输出点什么，我们只需要加一个MyDriverManager2，代码如下：
1
2
3
4
5
6
7
8
9
10
11
packagecom.model.structure;
publicclass MyDriverManager2 extends DriverManager {
publicvoid connect() {
System.out.println("before connect");
super.connect();
System.out.println("after connect");
}
}
再将Client代码中的MyDriverManager 改成 MyDriverManager2 ，执行结果如下：
1
2
3
4
5
6
before connect
connect mysql done!
after connect
before connect
connect db2 done!
after connect
六、组合模式
组合模式，将对象组合成树形结构以表示“部分-整体”的层次结构，组合模式使得用户对单个对象和组合对象的使用具有一致性。掌握组合模式的重点是要理解清楚 “部分/整体” 还有 ”单个对象“ 与 “组合对象” 的含义。
组合模式让你可以优化处理递归或分级数据结构。
《设计模式》：将对象组合成树形结构以表示“部分整体”的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性。
涉及角色：
Component：是组合中的对象声明接口，在适当的情况下，实现所有类共有接口的默认行为。声明一个接口用于访问和管理Component子部件。
Leaf：在组合中表示叶子结点对象，叶子结点没有子结点。
Composite：定义有枝节点行为，用来存储子部件，在Component接口中实现与子部件有关操作，如增加(add)和删除(remove)等。
比如现实中公司内各部门的层级关系，请看代码：
Component：是组合中的对象声明接口，在适当的情况下，实现所有类共有接口的默认行为。声明一个接口用于访问和管理Component子部件。
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
packagecom.model.structure;
publicabstract class Company {
privateString name;
publicCompany() {
}
publicCompany(String name) {
super();
this.name = name;
}
publicString getName() {
returnname;
}
publicvoid setName(String name) {
this.name = name;
}
protectedabstract void add(Company company);
protectedabstract void romove(Company company);
protectedabstract void display(intdepth);
}
Composite：定义有枝节点行为，用来存储子部件，在Component接口中实现与子部件有关操作，如增加(add)和删除(remove)等。
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
packagecom.model.structure;
importjava.util.ArrayList;
importjava.util.List;
publicclass ConcreteCompany extends Company {
privateList<Company> cList;
publicConcreteCompany() {
cList = new ArrayList();
}
publicConcreteCompany(String name) {
super(name);
cList = new ArrayList();
}
@Override
protectedvoid add(Company company) {
cList.add(company);
}
@Override
protectedvoid display(intdepth) {
StringBuilder sb = new StringBuilder("");
for(inti = 0; i < depth; i++) {
sb.append("-");
}
System.out.println(newString(sb) + this.getName());
for(Company c : cList) {
c.display(depth + 2);
}
}
@Override
protectedvoid romove(Company company) {
cList.remove(company);
}
}
Leaf：在组合中表示叶子结点对象，叶子结点没有子结点。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
packagecom.model.structure;
publicclass HRDepartment extends Company {
publicHRDepartment(String name) {
super(name);
}
@Override
protectedvoid add(Company company) {
}
@Override
protectedvoid display(intdepth) {
StringBuilder sb = new StringBuilder("");
for(inti = 0; i < depth; i++) {
sb.append("-");
}
System.out.println(newString(sb) + this.getName());
}
@Override
protectedvoid romove(Company company) {
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
packagecom.model.structure;
publicclass FinanceDepartment extends Company {
publicFinanceDepartment(String name) {
super(name);
}
@Override
protectedvoid add(Company company) {
}
@Override
protectedvoid display(intdepth) {
StringBuilder sb = new StringBuilder("");
for(inti = 0; i < depth; i++) {
sb.append("-");
}
System.out.println(newString(sb) + this.getName());
}
@Override
protectedvoid romove(Company company) {
}
}
Client：
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
packagecom.model.structure;
publicclass Client {
publicstatic void main(String[] args) {
Company root = new ConcreteCompany();
root.setName("北京总公司");
root.add(newHRDepartment("总公司人力资源部"));
root.add(newFinanceDepartment("总公司财务部"));
Company shandongCom = new ConcreteCompany("山东分公司");
shandongCom.add(newHRDepartment("山东分公司人力资源部"));
shandongCom.add(newFinanceDepartment("山东分公司账务部"));
Company zaozhuangCom = new ConcreteCompany("枣庄办事处");
zaozhuangCom.add(newFinanceDepartment("枣庄办事处财务部"));
zaozhuangCom.add(newHRDepartment("枣庄办事处人力资源部"));
Company jinanCom = new ConcreteCompany("济南办事处");
jinanCom.add(newFinanceDepartment("济南办事处财务部"));
jinanCom.add(newHRDepartment("济南办事处人力资源部"));
shandongCom.add(jinanCom);
shandongCom.add(zaozhuangCom);
Company huadongCom = new ConcreteCompany("上海华东分公司");
huadongCom.add(newHRDepartment("上海华东分公司人力资源部"));
huadongCom.add(newFinanceDepartment("上海华东分公司账务部"));
Company hangzhouCom = new ConcreteCompany("杭州办事处");
hangzhouCom.add(newFinanceDepartment("杭州办事处财务部"));
hangzhouCom.add(newHRDepartment("杭州办事处人力资源部"));
Company nanjingCom = new ConcreteCompany("南京办事处");
nanjingCom.add(newFinanceDepartment("南京办事处财务部"));
nanjingCom.add(newHRDepartment("南京办事处人力资源部"));
huadongCom.add(hangzhouCom);
huadongCom.add(nanjingCom);
root.add(shandongCom);
root.add(huadongCom);
root.display(0);
}
}
运行结果：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
北京总公司
--总公司人力资源部
--总公司财务部
--山东分公司
----山东分公司人力资源部
----山东分公司账务部
----济南办事处
------济南办事处财务部
------济南办事处人力资源部
----枣庄办事处
------枣庄办事处财务部
------枣庄办事处人力资源部
--上海华东分公司
----上海华东分公司人力资源部
----上海华东分公司账务部
----杭州办事处
------杭州办事处财务部
------杭州办事处人力资源部
----南京办事处
------南京办事处财务部
------南京办事处人力资源部
七、享元模式
享元模式的主要目的是实现对象的共享，即共享池，当系统中对象多的时候可以减少内存的开销，通常与工厂模式一起使用。
一提到共享池，我们很容易联想到Java里面的JDBC连接池，想想每个连接的特点，我们不难总结出：适用于作共享的一些个对象，他们有一些共有的属性，就拿数据库连接池来说，url、driverClassName、username、password及dbname，这些属性对于每个连接来说都是一样的，所以就适合用享元模式来处理，建一个工厂类，将上述类似属性作为内部数据，其它的作为外部数据，在方法调用时，当做参数传进来，这样就节省了空间，减少了实例的数量。
看下数据库连接池的代码：
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
packagecom.model.structure;
importjava.sql.Connection;
importjava.sql.DriverManager;
importjava.sql.SQLException;
importjava.util.Vector;
publicclass ConnectionPool {
privateVector<Connection> pool;
/* 公有属性 */
private String url = "jdbc:mysql://localhost:3306/test";
private String username = "root";
private String password = "root";
private String driverClassName = "com.mysql.jdbc.Driver";
private int poolSize = 100;
private static ConnectionPool instance = null;
Connection conn = null;
/* 构造方法，做一些初始化工作 */
private ConnectionPool() {
pool = new Vector<Connection>(poolSize);
for (int i = 0; i < poolSize; i++) {
try {
Class.forName(driverClassName);
conn = DriverManager.getConnection(url, username, password);
pool.add(conn);
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
/* 返回连接到连接池 */
public synchronized void release() {
pool.add(conn);
}
/* 返回连接池中的一个数据库连接 */
publicsynchronized Connection getConnection() {
if(pool.size() > 0) {
Connection conn = pool.get(0);
pool.remove(conn);
returnconn;
}else {
returnnull;
}
}
}
通过连接池的管理，实现了数据库连接的共享，不需要每一次都重新创建连接，节省了数据库重新创建的开销，提升了系统的性能！
0 0
