我们接着讨论设计模式，上篇文章我讲完了5种创建型模式，这章开始，我将讲下7种结构型模式：适配器模式、装饰模式、代理模式、外观模式、桥接模式、组合模式、享元模式。其中对象的适配器模式是各种模式的起源，我们看下面的图：

6、适配器模式（Adapter）

适配器模式将某个类的接口转换成客户端期望的另一个接口表示，目的是消除由于接口不匹配所造成的类的兼容性问题。主要分为三类：类的适配器模式、对象的适配器模式、接口的适配器模式。首先，我们来看看类的适配器模式，先看类图：

核心思想就是：有一个Source类，拥有一个方法，待适配，目标接口时Targetable，通过Adapter类，将Source的功能扩展到Targetable里，看代码：

[java] view plaincopy
  1. public class Source {
  2. public void method1() {
  3. System.out.println("this is original method!");
  4. }
  5. }
[java] view plaincopy
  1. public interface Targetable {
  2. /* 与原类中的方法相同 */
  3. public void method1();
  4. /* 新类的方法 */
  5. public void method2();
  6. }
[java] view plaincopy
  1. public class Adapter extends Source implements Targetable {
  2. @Override
  3. public void method2() {
  4. System.out.println("this is the targetable method!");
  5. }
  6. }

Adapter类继承Source类，实现Targetable接口，下面是测试类：

[java] view plaincopy
  1. public class AdapterTest {
  2. public static void main(String[] args) {
  3. Targetable target = new Adapter();
  4. target.method1();
  5. target.method2();
  6. }
  7. }

输出：

this is original method!
this is the targetable method!

这样Targetable接口的实现类就具有了Source类的功能。

对象的适配器模式

基本思路和类的适配器模式相同，只是将Adapter类作修改，这次不继承Source类，而是持有Source类的实例，以达到解决兼容性的问题。看图：

只需要修改Adapter类的源码即可：

[java] view plaincopy
  1. public class Wrapper implements Targetable {
  2. private Source source;
  3. public Wrapper(Source source){
  4. super();
  5. this.source = source;
  6. }
  7. @Override
  8. public void method2() {
  9. System.out.println("this is the targetable method!");
  10. }
  11. @Override
  12. public void method1() {
  13. source.method1();
  14. }
  15. }

测试类：

[java] view plaincopy
  1. public class AdapterTest {
  2. public static void main(String[] args) {
  3. Source source = new Source();
  4. Targetable target = new Wrapper(source);
  5. target.method1();
  6. target.method2();
  7. }
  8. }

输出与第一种一样，只是适配的方法不同而已。

第三种适配器模式是接口的适配器模式，接口的适配器是这样的：有时我们写的一个接口中有多个抽象方法，当我们写该接口的实现类时，必须实现该接口的所有方法，这明显有时比较浪费，因为并不是所有的方法都是我们需要的，有时只需要某一些，此处为了解决这个问题，我们引入了接口的适配器模式，借助于一个抽象类，该抽象类实现了该接口，实现了所有的方法，而我们不和原始的接口打交道，只和该抽象类取得联系，所以我们写一个类，继承该抽象类，重写我们需要的方法就行。看一下类图：

这个很好理解，在实际开发中，我们也常会遇到这种接口中定义了太多的方法，以致于有时我们在一些实现类中并不是都需要。看代码：

[java] view plaincopy
  1. public interface Sourceable {
  2. public void method1();
  3. public void method2();
  4. }

抽象类Wrapper2：

[java] view plaincopy
  1. public abstract class Wrapper2 implements Sourceable{
  2. public void method1(){}
  3. public void method2(){}
  4. }
[java] view plaincopy
  1. public class SourceSub1 extends Wrapper2 {
  2. public void method1(){
  3. System.out.println("the sourceable interface's first Sub1!");
  4. }
  5. }
[java] view plaincopy
  1. public class SourceSub2 extends Wrapper2 {
  2. public void method2(){
  3. System.out.println("the sourceable interface's second Sub2!");
  4. }
  5. }
[java] view plaincopy
  1. public class WrapperTest {
  2. public static void main(String[] args) {
  3. Sourceable source1 = new SourceSub1();
  4. Sourceable source2 = new SourceSub2();
  5. source1.method1();
  6. source1.method2();
  7. source2.method1();
  8. source2.method2();
  9. }
  10. }

测试输出：

the sourceable interface's first Sub1!
the sourceable interface's second Sub2!

达到了我们的效果！

讲了这么多，总结一下三种适配器模式的应用场景：

类的适配器模式：当希望将一个类转换成满足另一个新接口的类时，可以使用类的适配器模式，创建一个新类，继承原有的类，实现新的接口即可。

对象的适配器模式：当希望将一个对象转换成满足另一个新接口的对象时，可以创建一个Wrapper类，持有原类的一个实例，在Wrapper类的方法中，调用实例的方法就行。

接口的适配器模式：当不希望实现一个接口中所有的方法时，可以创建一个抽象类Wrapper，实现所有方法，我们写别的类的时候，继承抽象类即可。

7、装饰模式（Decorator）

顾名思义，装饰模式就是给一个对象增加一些新的功能，而且是动态的，要求装饰对象和被装饰对象实现同一个接口，装饰对象持有被装饰对象的实例，关系图如下：

Source类是被装饰类，Decorator类是一个装饰类，可以为Source类动态的添加一些功能，代码如下：

[java] view plaincopy
  1. public interface Sourceable {
  2. public void method();
  3. }
[java] view plaincopy
  1. public class Source implements Sourceable {
  2. @Override
  3. public void method() {
  4. System.out.println("the original method!");
  5. }
  6. }
[java] view plaincopy
  1. public class Decorator implements Sourceable {
  2. private Sourceable source;
  3. public Decorator(Sourceable source){
  4. super();
  5. this.source = source;
  6. }
  7. @Override
  8. public void method() {
  9. System.out.println("before decorator!");
  10. source.method();
  11. System.out.println("after decorator!");
  12. }
  13. }

测试类：

[java] view plaincopy
  1. public class DecoratorTest {
  2. public static void main(String[] args) {
  3. Sourceable source = new Source();
  4. Sourceable obj = new Decorator(source);
  5. obj.method();
  6. }
  7. }

输出：

before decorator!
the original method!
after decorator!

装饰器模式的应用场景：

1、需要扩展一个类的功能。

2、动态的为一个对象增加功能，而且还能动态撤销。（继承不能做到这一点，继承的功能是静态的，不能动态增删。）

缺点：产生过多相似的对象，不易排错！

8、代理模式（Proxy）

其实每个模式名称就表明了该模式的作用，代理模式就是多一个代理类出来，替原对象进行一些操作，比如我们在租房子的时候回去找中介，为什么呢？因为你对该地区房屋的信息掌握的不够全面，希望找一个更熟悉的人去帮你做，此处的代理就是这个意思。再如我们有的时候打官司，我们需要请律师，因为律师在法律方面有专长，可以替我们进行操作，表达我们的想法。先来看看关系图：

根据上文的阐述，代理模式就比较容易的理解了，我们看下代码：

[java] view plaincopy
  1. public interface Sourceable {
  2. public void method();
  3. }
[java] view plaincopy
  1. public class Source implements Sourceable {
  2. @Override
  3. public void method() {
  4. System.out.println("the original method!");
  5. }
  6. }
[java] view plaincopy
  1. public class Proxy implements Sourceable {
  2. private Source source;
  3. public Proxy(){
  4. super();
  5. this.source = new Source();
  6. }
  7. @Override
  8. public void method() {
  9. before();
  10. source.method();
  11. atfer();
  12. }
  13. private void atfer() {
  14. System.out.println("after proxy!");
  15. }
  16. private void before() {
  17. System.out.println("before proxy!");
  18. }
  19. }

测试类：

[java] view plaincopy
  1. public class ProxyTest {
  2. public static void main(String[] args) {
  3. Sourceable source = new Proxy();
  4. source.method();
  5. }
  6. }

输出：

before proxy!
the original method!
after proxy!

代理模式的应用场景：

如果已有的方法在使用的时候需要对原有的方法进行改进，此时有两种办法：

1、修改原有的方法来适应。这样违反了“对扩展开放，对修改关闭”的原则。

2、就是采用一个代理类调用原有的方法，且对产生的结果进行控制。这种方法就是代理模式。

使用代理模式，可以将功能划分的更加清晰，有助于后期维护！

9、外观模式（Facade）

外观模式是为了解决类与类之家的依赖关系的，像spring一样，可以将类和类之间的关系配置到配置文件中，而外观模式就是将他们的关系放在一个Facade类中，降低了类类之间的耦合度，该模式中没有涉及到接口，看下类图：（我们以一个计算机的启动过程为例）

我们先看下实现类：

[java] view plaincopy
  1. public class CPU {
  2. public void startup(){
  3. System.out.println("cpu startup!");
  4. }
  5. public void shutdown(){
  6. System.out.println("cpu shutdown!");
  7. }
  8. }
[java] view plaincopy
  1. public class Memory {
  2. public void startup(){
  3. System.out.println("memory startup!");
  4. }
  5. public void shutdown(){
  6. System.out.println("memory shutdown!");
  7. }
  8. }
[java] view plaincopy
  1. public class Disk {
  2. public void startup(){
  3. System.out.println("disk startup!");
  4. }
  5. public void shutdown(){
  6. System.out.println("disk shutdown!");
  7. }
  8. }
[java] view plaincopy
  1. public class Computer {
  2. private CPU cpu;
  3. private Memory memory;
  4. private Disk disk;
  5. public Computer(){
  6. cpu = new CPU();
  7. memory = new Memory();
  8. disk = new Disk();
  9. }
  10. public void startup(){
  11. System.out.println("start the computer!");
  12. cpu.startup();
  13. memory.startup();
  14. disk.startup();
  15. System.out.println("start computer finished!");
  16. }
  17. public void shutdown(){
  18. System.out.println("begin to close the computer!");
  19. cpu.shutdown();
  20. memory.shutdown();
  21. disk.shutdown();
  22. System.out.println("computer closed!");
  23. }
  24. }

User类如下：

[java] view plaincopy
  1. public class User {
  2. public static void main(String[] args) {
  3. Computer computer = new Computer();
  4. computer.startup();
  5. computer.shutdown();
  6. }
  7. }

输出：

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!

如果我们没有Computer类，那么，CPU、Memory、Disk他们之间将会相互持有实例，产生关系，这样会造成严重的依赖，修改一个类，可能会带来其他类的修改，这不是我们想要看到的，有了Computer类，他们之间的关系被放在了Computer类里，这样就起到了解耦的作用，这，就是外观模式！

10、桥接模式（Bridge）

桥接模式就是把事物和其具体实现分开，使他们可以各自独立的变化。桥接的用意是：将抽象化与实现化解耦，使得二者可以独立变化，像我们常用的JDBC桥DriverManager一样，JDBC进行连接数据库的时候，在各个数据库之间进行切换，基本不需要动太多的代码，甚至丝毫不用动，原因就是JDBC提供统一接口，每个数据库提供各自的实现，用一个叫做数据库驱动的程序来桥接就行了。我们来看看关系图：

实现代码：

先定义接口：

[java] view plaincopy
  1. public interface Sourceable {
  2. public void method();
  3. }

分别定义两个实现类：

[java] view plaincopy
  1. public class SourceSub1 implements Sourceable {
  2. @Override
  3. public void method() {
  4. System.out.println("this is the first sub!");
  5. }
  6. }
[java] view plaincopy
  1. public class SourceSub2 implements Sourceable {
  2. @Override
  3. public void method() {
  4. System.out.println("this is the second sub!");
  5. }
  6. }

定义一个桥，持有Sourceable的一个实例：

[java] view plaincopy
  1. public abstract class Bridge {
  2. private Sourceable source;
  3. public void method(){
  4. source.method();
  5. }
  6. public Sourceable getSource() {
  7. return source;
  8. }
  9. public void setSource(Sourceable source) {
  10. this.source = source;
  11. }
  12. }
[java] view plaincopy
  1. public class MyBridge extends Bridge {
  2. public void method(){
  3. getSource().method();
  4. }
  5. }

测试类：

[java] view plaincopy
  1. public class BridgeTest {
  2. public static void main(String[] args) {
  3. Bridge bridge = new MyBridge();
  4. /*调用第一个对象*/
  5. Sourceable source1 = new SourceSub1();
  6. bridge.setSource(source1);
  7. bridge.method();
  8. /*调用第二个对象*/
  9. Sourceable source2 = new SourceSub2();
  10. bridge.setSource(source2);
  11. bridge.method();
  12. }
  13. }

output：

this is the first sub!
this is the second sub!

这样，就通过对Bridge类的调用，实现了对接口Sourceable的实现类SourceSub1和SourceSub2的调用。接下来我再画个图，大家就应该明白了，因为这个图是我们JDBC连接的原理，有数据库学习基础的，一结合就都懂了。

11、组合模式（Composite）

组合模式有时又叫部分-整体模式在处理类似树形结构的问题时比较方便，看看关系图：

直接来看代码：

[java] view plaincopy
  1. public class TreeNode {
  2. private String name;
  3. private TreeNode parent;
  4. private Vector<TreeNode> children = new Vector<TreeNode>();
  5. public TreeNode(String name){
  6. this.name = name;
  7. }
  8. public String getName() {
  9. return name;
  10. }
  11. public void setName(String name) {
  12. this.name = name;
  13. }
  14. public TreeNode getParent() {
  15. return parent;
  16. }
  17. public void setParent(TreeNode parent) {
  18. this.parent = parent;
  19. }
  20. //添加孩子节点
  21. public void add(TreeNode node){
  22. children.add(node);
  23. }
  24. //删除孩子节点
  25. public void remove(TreeNode node){
  26. children.remove(node);
  27. }
  28. //取得孩子节点
  29. public Enumeration<TreeNode> getChildren(){
  30. return children.elements();
  31. }
  32. }
[java] view plaincopy
  1. public class Tree {
  2. TreeNode root = null;
  3. public Tree(String name) {
  4. root = new TreeNode(name);
  5. }
  6. public static void main(String[] args) {
  7. Tree tree = new Tree("A");
  8. TreeNode nodeB = new TreeNode("B");
  9. TreeNode nodeC = new TreeNode("C");
  10. nodeB.add(nodeC);
  11. tree.root.add(nodeB);
  12. System.out.println("build the tree finished!");
  13. }
  14. }

使用场景：将多个对象组合在一起进行操作，常用于表示树形结构中，例如二叉树，数等。

12、享元模式（Flyweight）

享元模式的主要目的是实现对象的共享，即共享池，当系统中对象多的时候可以减少内存的开销，通常与工厂模式一起使用。

FlyWeightFactory负责创建和管理享元单元，当一个客户端请求时，工厂需要检查当前对象池中是否有符合条件的对象，如果有，就返回已经存在的对象，如果没有，则创建一个新对象，FlyWeight是超类。一提到共享池，我们很容易联想到Java里面的JDBC连接池，想想每个连接的特点，我们不难总结出：适用于作共享的一些个对象，他们有一些共有的属性，就拿数据库连接池来说，url、driverClassName、username、password及dbname，这些属性对于每个连接来说都是一样的，所以就适合用享元模式来处理，建一个工厂类，将上述类似属性作为内部数据，其它的作为外部数据，在方法调用时，当做参数传进来，这样就节省了空间，减少了实例的数量。

看个例子：

看下数据库连接池的代码：

[java] view plaincopy
  1. public class ConnectionPool {
  2. private Vector<Connection> pool;
  3. /*公有属性*/
  4. private String url = "jdbc:mysql://localhost:3306/test";
  5. private String username = "root";
  6. private String password = "root";
  7. private String driverClassName = "com.mysql.jdbc.Driver";
  8. private int poolSize = 100;
  9. private static ConnectionPool instance = null;
  10. Connection conn = null;
  11. /*构造方法，做一些初始化工作*/
  12. private ConnectionPool() {
  13. pool = new Vector<Connection>(poolSize);
  14. for (int i = 0; i < poolSize; i++) {
  15. try {
  16. Class.forName(driverClassName);
  17. conn = DriverManager.getConnection(url, username, password);
  18. pool.add(conn);
  19. } catch (ClassNotFoundException e) {
  20. e.printStackTrace();
  21. } catch (SQLException e) {
  22. e.printStackTrace();
  23. }
  24. }
  25. }
  26. /* 返回连接到连接池 */
  27. public synchronized void release() {
  28. pool.add(conn);
  29. }
  30. /* 返回连接池中的一个数据库连接 */
  31. public synchronized Connection getConnection() {
  32. if (pool.size() > 0) {
  33. Connection conn = pool.get(0);
  34. pool.remove(conn);
  35. return conn;
  36. } else {
  37. return null;
  38. }
  39. }
  40. }

通过连接池的管理，实现了数据库连接的共享，不需要每一次都重新创建连接，节省了数据库重新创建的开销，提升了系统的性能！本章讲解了7种结构型模式，因为篇幅的问题，剩下的11种行为型模式，我们将另起篇章，敬请读者朋友们持续关注！

Java之美[从蛮荒到撬动地球]之设计模式二相关推荐

  1. 《国度》之大学者联盟找到了那个撬动地球的支点

    有很多人问我<国度>写了什么? 我说,这本书写的是我的志向,我的梦想,我的一个创业想法,我想要打造一个让人可以放心去相信,有乐趣,有意义,能依靠的平台,我给它取名为大学者联盟.它的基本组成 ...

  2. Java之美[从菜鸟到高手演变]系列之博文阅读导航

    随着博文越来越多,为博客添加一个导航很有必要!本博客将相继开通Java.CloudFoundry.Linux.Ruby等专栏,都会设立目录,希望读者朋友们能更加方便的阅读! 在阅读的过程中有任何问题, ...

  3. 给我一个兴趣点，我就能撬动一个行业

    给我一个兴趣点,我就能撬动一个行业 兴趣是什么?据百度百科解释:兴趣指 兴致,对事物喜好或关切的情绪.心理学人们力求认识某种事物和从事某项活动的意识倾向.它表现为人们对某件事物.某项活动的选择性态度和 ...

  4. “P图元祖”美图秀秀，如何撬动“高颜值”年轻人口袋？

    人之爱美,是人之通性.而女人爱美,则是女人天性. 从古至今,关于女人如何变美是永恒不变的话题.在这个风口下,催生了一门又一门或长久或短暂的颜值生意. 而在互联网时代,现代女性对于美的追求更加热烈.从Q ...

  5. 如何撬动机器学习的冰山一角？

    目前,人工智能的应用日渐广泛. 而作为人工智能核心的机器学习,是一门多领域的交叉学科,专门研究计算机模拟或实现人类学习行为的方法,以获取新的知识或技能,重新组织已有的知识结构使之不断改善自身的性能. ...

  6. 京东11·11：撬动数据中心的支点——京东阿基米德

    今年11.11,京东数据中心操作系统(JDOS)阿基米德已经全面接管了应用资源调度.每日调度百万台容器实例运转,每日为离线计算提供了多达3000万核·小时的计算资源,SLA履约率达到98.3%.在保证 ...

  7. NEC：借助AI撬动未来物联网世界

    看过<碟中谍>系列大片的朋友,可能对特工们在火车站庞大的人流中借用人脸识别隐形眼镜迅速锁定目标的场景惊叹不已,而这一幕已被NEC从梦想带到了现实.近日,NEC在东京高大上的场所--东京国际 ...

  8. 扇贝编程python是干嘛的-产品观察 | 以对话式互动学习撬动转化，扇贝编程瞄准职教市场...

    原标题:产品观察 | 以对话式互动学习撬动转化,扇贝编程瞄准职教市场 成人编程教育是职业教育行业最火热的赛道之一,除了行业内的垂直创业公司,越来越多教育公司也在把业务线延展至这一领域,以便深度结合业务 ...

  9. 【云周刊】第173期：直击数博|阿里胡晓明：用100亿的投入撬动1000亿的脱贫效应...

    2019独角兽企业重金招聘Python工程师标准>>> 本期头条 直击数博|阿里胡晓明:用100亿的投入撬动1000亿的脱贫效应  5月27日,在贵阳数博会"精准扶贫&qu ...

  10. Java之美[从菜鸟到高手演变]之Exception

    版权声明:本文为博主原创文章,未经博主允许不得转载. Exception这个东西,程序中必须会有的,尽管我们很不乐意看到它,可是从另一个角度考虑,有异常则说明程序有问题,有助于我们及时改正.有的时候程 ...

最新文章

  1. php true true true,php-为什么此评估为true
  2. 线程里面的yield();方法（让出线程）
  3. javascript ES6
  4. 7个Python特殊技巧，助力你的数据分析工作之路
  5. SameNameFile 比较两个文件夹是否同名
  6. linux系统多网口聚合配置,Linux网卡聚合linux多网卡绑定聚合之bond模式的原理是什么...
  7. [2020-ECCV]PIPAL-a Large-Scale Image Quality Assessment Dataset for Perceptual Image Restoration论文简析
  8. Could NOT find OpenSSL, try to set the path to OpenSSL root folder in the system variable
  9. Focal loss原理解析
  10. Filter In Baan!
  11. RHEL 7.2 源码安装Python 3.6.2报错
  12. css阿拉伯数字,css 古文排版(含阿拉伯数字)
  13. Markdown 语法支持测试
  14. 单声道蓝牙实现音乐播放
  15. Android计步模块优化（今日步数）
  16. 说说汉古中医对新型冠状病毒感染的认识和防治
  17. 2022年河南省焊工高级技师理论知识模拟试题及答案
  18. ROP Emporium ret2csu
  19. subprocess
  20. 男女通用的城府修练 城府不是有心眼，而是成熟

热门文章

  1. java pdf 转tif_JAVA中 PDF文件转成TIFF文件的2种方式
  2. linux mint 下安装 wwscan
  3. 【数据产品案例】阿里生意参谋-用户分析
  4. 生意参谋指数转化算法(2021最新)
  5. fastDFS原理及环境搭建
  6. 斐波那契堆 - 解析与实现
  7. 三通短信每月发送量导入Sqlserver随笔
  8. 查看CentOS系统配置情况命令
  9. PMP备考经验分享 制表很重要
  10. openwrt1907 mt7621配置DDR自适应