第11章 GoF设计模式(二)

最新推荐文章于 2022-07-28 21:16:52 发布

等的人心好烦

最新推荐文章于 2022-07-28 21:16:52 发布

阅读量222

点赞数

分类专栏： uml

本文链接：https://blog.csdn.net/yongchaocsdn/article/details/79038852

版权

uml 专栏收录该内容

29 篇文章 0 订阅

订阅专栏

适用性
想使用一个已经存在的类，而它的接口不符合你的需求
想创建一个可以复用的类，该类可以与其他不相关的类或者不可预见的类协同工作。
想使用一些已经存在的子类，但不可能对每一个都进行子类化以匹配它们的接口。（仅适用于对象适配器）
结构

参与者
Client
与符合Target接口的对象协同
Target
定义Client使用的与特定领域相关的接口
Adaptee
定义一个已经存在的接口，该接口需要适配
Adapter
对Aptee接口与Target接口进行适配
协作
Client在Adapter实例上调用一些操作。接着适配器调用Adaptee的操作实现这个请求

11.4.3 桥接模式（Bridge）

意图
将抽象部分与它的实现部分分离，使它们都可以独立地变化。
别名
Handle/Body

动机
       当一个抽象可能有多个实现时，通常用继承来协调它们。
       抽象类定义对该抽象的接口，具体子类则用不同的方式加以实现。
       但此方法有时不够灵活。
适用性
不希望在抽象和它的实现部分之间有一个固定的绑定关系
类的抽象以及它的实现都应该可以通过生成子类的方法加以扩充
对一个抽象的部分的修改不对客户产生影响
结构

参与者
Abstraction
定义抽象类的接口
RefinedAbstraction
扩充的抽象接口
Implementor
定义实现类的接口
ConcreteImplementor
具体实现类
协作
Abstraction将client的请求转发给它的Implementor

11.4.4 组合模式（Composite）

意图
将对象组合成树形结构以表示“部分-整体”的层次结构。使得用户对单个对象和组合对象的使用具有一致性。
动机
绘图编辑器类似应用中，可以定义Text、Line图元类，和容器类Container
存在问题：必须区别对待图元与容器，使得程序复杂。
Composite模式描述如何使用递归组合
适用性
想表示对象的部分——整体层次关系。
希望用户忽略组合对象与单个对象的不同，统一使用组合结构中的所有对象。
结构

参与者
Component
为组合的对象声明接口
实现所有类共有接口的缺省行为
声明一个接口用于访问和管理Component的子组件
Leaf
在组合中表示叶子节点
在组合中定义图元对象的行为
Composite
定义有子部件的那些部件的行为
存储子部件
实现与子部件有关的操作
Client
效果
定义了包含基本对象和组合对象的层次结构
简化客户代码
更容易增加新类型的组件

使设计更一般化，增加新组件也会产生一些问题

11.4.5 装饰模式（Decorator）

意图
       动态地给一个对象添加一些额外的职责。
别名
包装器 Wrapper
动机
        有时需要给某个对象而不是整个类添加一些功能。
        使用继承不够灵活。
结构

参与者
Component：
抽象组件
ConcreteComponent：
具体组件
Decorator：
装饰角色抽象类
ConcreteDecorator：
具体装饰对象
效果
比静态继承更灵活
避免在层次结构高层的类有太多的特性

11.4.6 外观模式（Facade）

意图
为子系统的一组接口提供一个一致的接口，使子系统更容易使用。
动机

适用性
要为一个复杂子系统提供一个简单接口时。
客户程序与抽象类的实现部分之间存在很大依赖性。需要将子系统与客户系统分离提高独立性和可移植性。
需要构建层次结构的子系统时，如果子系统之间相互依赖，为简化依赖关系
结构

参与者
Façade
知道哪些子系统负责处理请求
将客户的请求代理给适当的系统对象
Subsystem classes
实现子系统的功能
处理有Façade对象指派的任务
协作
客户程序通过发送请求给Façade的方式与子系统通讯
客户程序不需要直接访问子系统对象
效果
对客户屏蔽子系统组件，使用更加方便
实现了子系统与客户之间的松散耦合
如果应用需要，并不限制使用子系统。

11.4.7 代理模式（Proxy）

意图
       为其他对象提供一种代理以控制对这个对象的访问。
别名
        Surrogate
动机
        如代理商、代理服务器应用场景
适用性
        用通用和复杂的对象指针代替简单指针时。
常见情况：
远程代理
虚代理
保护代理
智能引用
结构

参与者
Proxy
保存一个引用，使得代理可以访问实体
提供一个与Subject接口相同的接口
控制对实体的访问，负责创建和删除它
其他依赖于代理类型的功能
Subject
定义RealSubject和Proxy的共用接口
RealSubject
定义所代表的实体

11.5 结构型模式比较

Adapter vs Bridge
相同点
都给另一个对象提供一定程度上的间接性，有利于系统灵活性。
区别
Adapter主要解决两个已有接口之间的不匹配的问题。
Bridge则对抽象接口与它的实现部分进行桥接。
Composite vs Decorator
       Composite与Decorator有类似的结构图，都是基于递归组合来组织可变数目的对象。
       Decorator旨在不需要生成子类即可给对象添加职责，避免了静态实现所有功能的组合。
      Composite旨在构造类，使多个相关的对象能够以统一的方式处理。重点不在修饰而在表示。
Decorator vs Proxy
       这两种模式都描述了怎样为对象提供一定程度上的间接引用。
        Proxy模式不能动态添加或分离性质。
        在Decorator模式中，组件仅提供部分功能，而一个或多个Decrator完成其他功能。
示例
        观看运动员练习赛

用代理模式

//用代理模式实现

public interface  IRunner{
    public void  run();
}

public class  Runner  implements IRunner{
    public void run(){
        System.out.println(“运动员跑步：动作潇洒”);
    }
}
public  class  RunnerAgent  implements  IRunner{
   private  IRunner  runner;
   public RunnerAgent(IRunner  _runner){
        this.runner = _ruuner;
   }
public void run(){   //代理人不会跑
       Random  rand=new Random();
       if(rand.nextBoolean()) {
          System.out.println(“跑”); runner.run();
       else System.out.println(“不跑”);
   }
}
public class Client{
    public static void main(String[] args){
        //定义运动员
        IRunner   liu = new Runner();
        //定义代理
        IRunner  agent = new RnnerAgent(liu);
        //要求跑步
        System.out.println(“客人要运动员跑步”);
        agent.run();
    }
}

//用装饰模式实现

public class RunnerWithJet  implements  IRunner{
    private IRuuner  runner;
    public  RunnerWithJet  (IRunner  _runner){
        this.runner = _runner;
    }
    public  void run(){
        System.out.println(“运动员增加喷气式装置”);
        runner.run();
    }
}
public class Client{
    public static void main(String[] args){
        //定义运动员
        IRunner   liu = new Runner();
        //看跑步情况
	liu = new RunnerWithJet(liu);
        System.out.println(“增强后的运动员跑步”);
        liu.run();
    }
}

Decorator vs Adapter
        两者在通用类图上没有太多相似点，但功能有相似地方：都是包装作用，都是通过委托方式实现其功能。
       不同点：装饰模式包装的是自己的兄弟类，隶属于同一家族（相同的接口或父类）。
       适配器模式则修饰血缘关系类，把一个非本家族的对象伪装成本家族的对象。
示例：丑小鸭
//装饰模式

public interface  Swan{
    public  void fly();
    public  void cry();
    public  void desAppearance()
}
public class UglyDucking  implements  Swan{
    public void cry(){
        System.out.println(“克鲁－克鲁”);
　｝
 　public void desAppaerance(){
         System.out.println(“脏兮兮”);
    }
    public  void  fly(){
        System.out.println(“不能飞”);
    }
}
public class  Decorator implements Swan{
    private  Swan  swan;
    public  Decorator(Swan  _swan){
        this.swan = _swan;
    }
    public void cry(){        this.cry();     }
    public  void  desAppaerance(){        swan.desAppaerance();
    }
    public void fly(){ swan.fly();}
}
public class BeautyAppear extends Decorator{
    public BeautyAppear(Swan  _swan){
        super(_swan);
   }
   @Override
   public void desAppaerance(){
       System.out.println(“外表纯白色”);
   }
}
public class  StrongBehavior  extends  Decorator{
    public StrongBehavior(Swan _swan){
        super(_swan);
    }
    public void fly(){
        System.out.println(“会飞了”);
    }
}
public class  Client{
    public static void main(String[] main){
        Swan  duckling = new UglyDuckling();
        duckling.desAppearance();
        duckling.cry();
        duckling.fly();
        duckling = new BeautyAppear(duckling);
        duckling = new StrongBehavior(duckling);
        duckling.desAppearance();
        duckling.cry();
        duckling.fly();
}}

//适配器模式

public interface  Duck{
    public void cry();
    public void deAppearance();
    public void  desBehavior();
}
public class  Duckling implements Duck{
    public void cry(){System.out.println(“嘎-嘎”);}
    public void desAppearance(){
        System.out.println(“黄白相间，嘴长”);
    }
    public void desBehavior(){S.o.println(“会游泳”);}
}
public class  WhiteSwan  implements  Swan{
    public  void cry(){
        System.out.println(“克鲁-克鲁”);
    }
    public void desAppaerance(){
        System.out.println(“纯白色”);
    }
    public  void  fly(){
        System.out.println(“I can  fly”);
    }
}
public class  UglyDuckling extends WhitSwan implements  Duck{
    public void fly(){super.cry()}
    public void desAppearance(){
        super.desAppearance():
    }
    public void  desBehavior(){
        System.out.println(“会游泳”);
         super.fly();
    }
}
public class Client{
    public static void main(String[] main){
        Duck  duck=new Duckling();
        duck.cry();
        duck.desAppearance();
        duck.desBehavior();
        Duck  ugly=new UglyDuckling();
        ugly.cry();
        ugly.desAppearance();
        ugly.desBehavior();
    }
}

小结

结构型设计模式涉及如何组合类和对象以获得更大的结构。
适配器模式可用于类或者对象，使两种不兼容类型协同工作。
桥接模式将对象的抽象和实现分离
组合模式将对象组织成树形结构
装饰模式描述了如何动态地为对象添加职责
外观模式为子系统提供一个统一的接口
代理模式提供了对对象的一些特有性质的间接访问

等的人心好烦

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
第11章 GoF设计模式(二)

目录11.4 结构型设计模式概述适配器模式桥接模式组合模式装饰模式外观模式代理模式11.5 结构型模式比较适配器与桥接组合、装饰与代理装饰与适配器11.4.1 结构型模式概述结构型模式涉及到如何组合类和对象以获得更大的结构。结构型类模式采用继承机制来组合接口或接口的实现。结构型对象模式描述如何对一些对象进行组合，从而实现新功能的一些
复制链接

扫一扫