设计模式14---结构型模式总结

概述

　　结构型模式共七种：

• 适配器模式（Adapter）　　　　　　　　
• 外观模式（Facade）
• 桥接模式（Bridge）
• 装饰器模式（Decorator）
• 代理模式（Proxy）
• 享元模式（Flyweight）
• 组合模式（Composite）

　　其中又分为

　　接口适配：适配器、外观、桥接模式

　　行为扩展：装饰

　　性能与对象访问：代理、享元模式

　　抽象集合：组合模式

一、适配器模式

　　定义：将一个类的接口转换成客户希望的另外一个接口，Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。

　　角色：适配器（Adapter）、被适配类、对象（Adaptee）

　　理解：客户需要Target，现实只有Adaptee，可以用一个实现Target协议的适配器通过类继承或者对象组合类获得被Adaptee。

　　类图：

　　

　　例子代码：

// 原有的接口，不符合客户要求
interface IOrigin{
    public void deal();
}
// 定义一个符合客户要求的新接口
interface ITarget{
    public void newDeal(int type);
}
class Target implements ITarget{
    private IOrigin origin;
    public void newDeal(int type){
        if (type==0){
            origin.deal();
        }else{
            //做其他
        }
    }
}
public class TestAdapter {
    public  void test(){
        // 原来是IOrigin接口但是不符合我要求，所以用ITarget适配一下
        // 
        ITarget target = new Target();
        target.newDeal(1);
    }
}

二、外观模式

　　定义：为子系统中一组不同的接口提供统一的接口

　　什么时候用：1.子系统正逐渐变得复杂，应用模式的过程中演化出许多类。可以使用外观为这些子系统类提供一个较简单的接口。2.可以使用外观对子系统分层，每个字系统级别有一个外观做为入口。让她们通过外观进行通信，可以简化他们的依赖关系。

　　类图：

　　例子代码：

// 一个维修汽车厂系统包括，小车维修、公交维修、验收 
// 小车
class Car{
    // 维修
    public void repair();
}
// 公车
class Bus{
    // 维修
    public void repair();
}
// 维修人员
class Repairer{
    public void doRepair();
}
// 验收人员
class Checker{
    public void doCheck();
}

// 老板不可能管的那么细，他需要雇佣一个经理
class Leader{
    private Repairer repairer;
    private Checker checker;
    public void repair();
    public boolean check();
}
public class TestFacade {
    public void test(){
        // 老板接一个单子时，直接叫经理去修车，然后再问经理是否完成,这个经理就是一个外观
        Leader leader = new Leader();
        // 通知经理修车，不管经理下面有多少个维修人员，验收人员
        leader.repair();
        boolean isOk = leader.check();
    }
}

三、桥接模式

　　定义：将抽象部分与它的实现部分分离，使它可以独立的变更

　　角色：抽象层接口（Abstraction）、具体抽象层、实现者接口、具体实现者。

　　理解：这里有两个接口，一个是抽象层接口Abstraction，一个是Implementor接口，其中Abstraction持有Implementor的引用。客户端通过Abstraction来连接Implementor，以后Implementor可以动态的改变而不影响Abstraction。　　

　　什么时候用：1.不想在抽象与实现之间形成固定的绑定关系（这样就能在运行时切换实现）。2.抽象与实现都应可以通过子类化独立进行扩展。
3.对抽象的实现进行修改不应影响客户端代码。4.如果每个实现需要额外的子类以细化抽象，则说明有必要把它们分成两个部分。5.想在带有不同抽象接口的多个对象之间共享一个实现。

　　类图：

　　

　　例子代码：

interface ILeader{
    public void doSomething();
}
class LeaderA implements ILeader{
    @Override
    public void doSomething() {}
}
class LeaderB implements ILeader{
    @Override
    public void doSomething() {}
}
class Boss {
    ILeader leader;
    public void setLeader(ILeader leader) {
        this.leader = leader;
    }
    public void doSomething(){
        this.leader.doSomething();
    }
}
public class TestBirdge {
    public void test(){
        Boss boss = new Boss();
        LeaderA leaderA = new LeaderA();
        boss.setLeader(leaderA);
        boss.doSomething();
        // 当某个经理离职的时候，老板可以再找一个有经验的经理来做事,
        LeaderB leaderB = new LeaderB();
        boss.setLeader(leaderB);
        boss.doSomething();
    }
}

四、装饰器模式

　　定义：动态的给对象添加一些额外的责任，就增加功能来说，装饰比生成子类更为灵活。

　　角色：组件接口（Component）、具体的组件、继承至Component的修饰接口（Decorator）、具体的修饰

　　理解：修饰接口Decorator继承Component，并持有Component的一个引用，所以起到了复用Component并增加新的功能。

　　什么时候用：1.想要在不影响其他对象的情况下，以动态、透明的方式给单个对象添加职责。2.想要扩展一个类的行为，却做不到。类定义可能被隐藏，无法进行子类化；或者对类的每个行为的扩展，哦支持每种功能组合，将产生大量的子类。

　　类图：

 

　　例子代码：

interface ICar{
    public void run();
}
class Car implements ICar{
    @Override
    public void run() {

    }
}
// 现在想给汽车添加 氮气加速
// 下面用子类化方式实现
class SubClassCar extends Car{
    @Override
    public void run() {
        this.addNitrogen();
        super.run();
    }
    public void addNitrogen(){}
}
// 下面用装饰模式实现
class DecoratorCar implements ICar{
    private Car car;
    @Override
    public void run() {
        this.addNitrogen();
        car.run();
    }
    public void addNitrogen(){}
}
public class TestDecorator {
    public void test(){
        
    }
} 

五、代理模式

　　定义：为其他对象提供一种代理以控制对这个对象的访问

　　角色：客户端（Client）、目标接口（subject）代理对象（Proxy）、真正的目标对象（RealSubject）

　　虚拟代理：客户端拥有Subject的引用，其实就是Proxy对象，Proxy对象持有RealSubject的引用，调用Proxy.request   Proxy会实际调用RealSubject.request

　　类图：

 

　　例子代码：

// 一个顾客要买房
class Customer{
    public void sellHouse(){
    }
}
class Proxy {
    private Customer customer;
    public void buyHouse(){
        customer.sellHouse();
    }
}
public class TestProxy {
    public void test(){
        // 一个买家要买房的话直接跟中介（代理）大交道就可以了
        Proxy proxy = new Proxy();
        proxy.buyHouse();
    }
} 

六、组合模式

　　定义：将对象组合成树形结构以表示’部分-整体’的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性。

　　理解：组合模式让我们可以把相同的基类型的对象组合到树状结构中，其中父节点包含同类型的子节点。

　　什么时候用：1.想获得对象抽象的树形表示（部分-整体层次结构）。2.想让客户端统一处理组合结构中的所有对象。
　　类图：

七、享元模式

　　定义：运用共享技术有效地支持大量细粒度的对象。

　　角色：享元池、享元接口、具体享元对象

　　理解：客户端需要享元对象时，先去享元池寻找，如果找到了就直接复用，如果没有找到就创建享元对象并保存到享元池。

　　类图：

总结：

1. Adapte适配器模式：Adapter模式通过类的继承或者对象的组合侧重于转换已有的接口，类适配器采用“多继承”的实现方式，带来了不良的高耦合。对象适配器采用“对象组合”的方式，更符合松耦合精神。
  例如：每种手机的接口不一样，使用与之匹配的数据线，还有转接头可以使不同的接口连接在一起。
2. Bridge桥接模式：将抽象部分与实现部分分离，使它们都可以独立的变化。减少因变化带来的代码的修改量。
 例如：串并联电路中，与或非门都可以实现让电路通电。
3. Composite组合模式：将对象组合成树形结构以表示“部分-整体”的层次结构。Composite模式使得客户对单个对象和组合对象的使用具有一致性。从而解决了解决客户程序与复杂对象容器的解耦，即：通过继承统一的接口，我们可以将容器对象及其子对象看成同一类对象使用，以减少对象使用中的复杂度。
 例如：像积木一样，由一块块最基础的可以堆成简单的房子，也可以堆成复杂的房子。
4. Decorator装饰模式：动态地给一个对象添加一些额外的职责。就增加功能来说，Decorator模式相比生成子类更为灵活。Decorator模式采用对象组合而非继承的手法，实现了在运行时动态的扩展对象功能的能力，而且可以根据需要扩展多个功能，避免了单独使用继承带来的“灵活性差”和“多子类衍生问题”。同时它很好地符合面向对象设计原则中“优先使用对象组合而非继承”和“开放-封闭”原则。
例如：一幅画，可以直接挂到墙上，也可以加上框架和镶上玻璃后，再挂到墙上。
5. Facade外观模式：为子系统中的一组接口提供一个一致的界面，简化接口。
例如：我们拨打10086，可以办理，彩铃，手机报，全时通等业务（子对象），而10086则是为子对象所使用的一致界面。
6. Flyweight享元模式：运用共享技术有效地支持大量细粒度的对象。解决：　面向对象的思想很好地解决了抽象性的问题，一般也不会出现性能上的问题。但是在某些情况下，对象的数量可能会太多，从而导致了运行时的代价。那么我们如何去避免大量细粒度的对象，同时又不影响客户程序使用面向对象的方式进行操作，享元模式的出现恰好解决了该问题。
　例如：公共交换电话网（PSTN）是享元的一个例子。有一些资源例如拨号音发生器、振铃发生器和拨号接收器是必须由所有用户共享的。当一个用户拿起听筒打电话时，他不需要知道使用了多少资源。对于用户而言所有的事情就是有拨号音，拨打号码，拨通电话。
7. Proxy代理模式：为其他对象提供一种代理以控制这个对象的访问。解决直接访问某些对象是出现的问题。
例如：中介是我们最常见的一个代理！