结构型模式描述如何将类或对象按某种布局组成更大的结构。它分为类结构型模式和对象结构型模式，前者采用继承机制来组织接口和类，后者釆用组合或聚合来组合对象。
由于组合关系或聚合关系比继承关系耦合度低，满足“合成复用原则”，所以对象结构型模式比类结构型模式具有更大的灵活性。
结构型模式分为以下 7 种：
代理（Proxy）模式：为某对象提供一种代理以控制对该对象的访问。即客户端通过代理间接地访问该对象，从而限制、增强或修改该对象的一些特性。适配器（Adapter）模式：将一个类的接口转换成客户希望的另外一个接口，使得原本由于接口不兼容而不能一起工作的那些类能一起工作。桥接（Bridge）模式：将抽象与实现分离，使它们可以独立变化。它是用组合关系代替继承关系来实现的，从而降低了抽象和实现这两个可变维度的耦合度。装饰（Decorator）模式：动态地给对象增加一些职责，即增加其额外的功能。外观（Facade）模式：为多个复杂的子系统提供一个一致的接口，使这些子系统更加容易被访问。享元（Flyweight）模式：运用共享技术来有效地支持大量细粒度对象的复用。组合（Composite）模式：将对象组合成树状层次结构，使用户对单个对象和组合对象具有一致的访问性。代理模式的定义：由于某些原因需要给某对象提供一个代理以控制对该对象的访问。这时，访问对象不适合或者不能直接引用目标对象，代理对象作为访问对象和目标对象之间的中介。
代理模式的主要优点有：
代理模式在客户端与目标对象之间起到一个中介作用和保护目标对象的作用；代理对象可以扩展目标对象的功能；代理模式能将客户端与目标对象分离，在一定程度上降低了系统的耦合度；代理模式的结构比较简单，主要是通过定义一个继承抽象主题的代理来包含真实主题，从而实现对真实主题的访问，下面来分析其基本结构和实现方法。 模式的结构 代理模式的主要角色如下。
抽象主题（Subject）类：通过接口或抽象类声明真实主题和代理对象实现的业务方法。真实主题（Real Subject）类：实现了抽象主题中的具体业务，是代理对象所代表的真实对象，是最终要引用的对象。代理（Proxy）类：提供了与真实主题相同的接口，其内部含有对真实主题的引用，它可以访问、控制或扩展真实主题的功能。 package proxy; public class ProxyTest { public static void main(String[] args) { Proxy proxy=new Proxy(); proxy.Request(); } } //抽象主题 interface Subject { void Request(); } //真实主题 class RealSubject implements Subject { public void Request() { System.out.println("访问真实主题方法..."); } } //代理 class Proxy implements Subject { private RealSubject realSubject; public void Request() { if (realSubject==null) { realSubject=new RealSubject(); } preRequest(); realSubject.Request(); postRequest(); } public void preRequest() { System.out.println("访问真实主题之前的预处理。"); } public void postRequest() { System.out.println("访问真实主题之后的后续处理。"); } }适配器模式（Adapter）的定义如下：将一个类的接口转换成客户希望的另外一个接口，使得原本由于接口不兼容而不能一起工作的那些类能一起工作。适配器模式分为类结构型模式和对象结构型模式两种，前者类之间的耦合度比后者高，且要求程序员了解现有组件库中的相关组件的内部结构，所以应用相对较少些。
模式的结构 适配器模式（Adapter）包含以下主要角色。
目标（Target）接口：当前系统业务所期待的接口，它可以是抽象类或接口。适配者（Adaptee）类：它是被访问和适配的现存组件库中的组件接口。适配器（Adapter）类：它是一个转换器，通过继承或引用适配者的对象，把适配者接口转换成目标接口，让客户按目标接口的格式访问适配者 模式的实现 //目标接口 public interface Target { //目标角色有自己的方法 public void request(); } //适配者接口 public class Adaptee { //原有的业务逻辑 public void doSomething() { System.out.println("I'm kind of busy,leave me alone,pls!"); } } //类适配器类 public class Adapter extends Adaptee implements Target { public void request() { super.doSomething(); } } public class Client { public static void main(String[] args) { //原有的业务逻辑 Target target = new ConcreteTarget(); target.request(); //现在增加了适配器角色后的业务逻辑 Target target2 = new Adapter(); target2.request(); } }适配器模式（Adapter）通常适用于以下场景。
以前开发的系统存在满足新系统功能需求的类，但其接口同新系统的接口不一致。使用第三方提供的组件，但组件接口定义和自己要求的接口定义不同。桥接（Bridge）模式的定义如下：将抽象与实现分离，使它们可以独立变化。它是用组合关系代替继承关系来实现，从而降低了抽象和实现这两个可变维度的耦合度。
桥接（Bridge）模式的优点是：
由于抽象与实现分离，所以扩展能力强；其实现细节对客户透明。模式的结构 桥接（Bridge）模式包含以下主要角色。
抽象化（Abstraction）角色：定义抽象类，并包含一个对实现化对象的引用。扩展抽象化（Refined Abstraction）角色：是抽象化角色的子类，实现父类中的业务方法，并通过组合关系调用实现化角色中的业务方法。实现化（Implementor）角色：定义实现化角色的接口，供扩展抽象化角色调用。具体实现化（Concrete Implementor）角色：给出实现化角色接口的具体实现。模式的实现
//实现化角色 public interface Implementor { //基本方法 public void doSomething(); public void doAnything(); } //具体实现化角色 public class ConcreteImplementor1 implements Implementor { public void doSomething() { //业务逻辑处理 } public void doAnything() { //业务逻辑处理 } } public class ConcreteImplementor2 implements Implementor { public void doSomething() { //业务逻辑处理 } public void doAnything() { //业务逻辑处理 } } //抽象化角色 public abstract class Abstraction { //定义对实现化角色的引用 private Implementor imp; //约束子类必须实现该构造函数 public Abstraction(Implementor _imp){ this.imp = _imp; } //自身的行为和属性 public void request(){ this.imp.doSomething(); } //获得实现化角色 public Implementor getImp(){ return imp; } } //具体抽象化角色 public class RefinedAbstraction extends Abstraction { //覆写构造函数 public RefinedAbstraction(Implementor _imp) { super(_imp); } //修正父类的行为 @Override public void request() { /* * 业务处理... */ super.request(); super.getImp().doAnything(); } } public class Client { public static void main(String[] args) { //定义一个实现化角色 Implementor imp = new ConcreteImplementor1(); //定义一个抽象化角色 Abstraction abs = new RefinedAbstraction(imp); //执行行文 abs.request(); } }例如继承层次过渡、无法更细化设计颗粒等场景，需要考虑使用桥梁模式。
接口或抽象类不稳定的场景明知道接口不稳定还想通过实现或继承来实现业务需求，那是得不偿失的，也是比较失 败的做法。
重用性要求较高的场景设计的颗粒度越细，则被重用的可能性就越大，而采用继承则受父类的限制，不可能出 现太细的颗粒度。
装饰（Decorator）模式的定义：指在不改变现有对象结构的情况下，动态地给该对象增加一些职责（即增加其额外功能）的模式，它属于对象结构型模式。
装饰（Decorator）模式的主要优点有：
采用装饰模式扩展对象的功能比采用继承方式更加灵活。可以设计出多个不同的具体装饰类，创造出多个不同行为的组合。模式的结构 装饰模式主要包含以下角色。
抽象构件（Component）角色：定义一个抽象接口以规范准备接收附加责任的对象。具体构件（Concrete Component）角色：实现抽象构件，通过装饰角色为其添加一些职责。抽象装饰（Decorator）角色：继承抽象构件，并包含具体构件的实例，可以通过其子类扩展具体构件的功能。具体装饰（ConcreteDecorator）角色：实现抽象装饰的相关方法，并给具体构件对象添加附加的责任。模式的实现
public abstract class Component { //抽象的方法 public abstract void operate(); } public class ConcreteComponent extends Component { //具体实现 @Override public void operate() { System.out.println("do Something"); } } public abstract class Decorator extends Component { private Component component = null; //通过构造函数传递被修饰者 public Decorator(Component _component) { this.component = _component; } //委托给被修饰者执行 @Override public void operate() { this.component.operate(); } } public class Client { public static void main(String[] args) { Component component = new ConcreteComponent(); //第一次修饰 component = new ConcreteDecorator1(component); //第二次修饰 component = new ConcreteDecorator2(component); //修饰后运行 component.operate(); } }装饰模式可以替代继承，解决我们类膨胀的问题。
外观（Facade）模式的定义：是一种通过为多个复杂的子系统提供一个一致的接口，而使这些子系统更加容易被访问的模式。该模式对外有一个统一接口，外部应用程序不用关心内部子系统的具体的细节，这样会大大降低应用程序的复杂度，提高了程序的可维护性。
外观（Facade）模式是“迪米特法则”的典型应用，它有以下主要优点。
降低了子系统与客户端之间的耦合度，使得子系统的变化不会影响调用它的客户类。对客户屏蔽了子系统组件，减少了客户处理的对象数目，并使得子系统使用起来更加容易。降低了大型软件系统中的编译依赖性，简化了系统在不同平台之间的移植过程，因为编译一个子系统不会影响其他的子系统，也不会影响外观对象。外观（Facade）模式的主要缺点如下。
不能很好地限制客户使用子系统类。增加新的子系统可能需要修改外观类或客户端的源代码，违背了“开闭原则”。外观（Facade）模式的结构比较简单，主要是定义了一个高层接口。它包含了对各个子系统的引用，客户端可以通过它访问各个子系统的功能。现在来分析其基本结构和实现方法。 模式的结构 外观（Facade）模式包含以下主要角色。
外观（Facade）角色：为多个子系统对外提供一个共同的接口。子系统（Sub System）角色：实现系统的部分功能，客户可以通过外观角色访问它。客户（Client）角色：通过一个外观角色访问各个子系统的功能。模式的实现
public class FacadePattern { public static void main(String[] args) { Facade f = new Facade(); f.method(); } } //外观角色 class Facade { private SubSystem01 obj1 = new SubSystem01(); private SubSystem02 obj2 = new SubSystem02(); private SubSystem03 obj3 = new SubSystem03(); public void method() { obj1.method1(); obj2.method2(); obj3.method3(); } } //子系统角色 class SubSystem01 { public void method1() { System.out.println("子系统01的method1()被调用！"); } } //子系统角色 class SubSystem02 { public void method2() { System.out.println("子系统02的method2()被调用！"); } } //子系统角色 class SubSystem03 { public void method3() { System.out.println("子系统03的method3()被调用！"); } }享元（Flyweight）模式的定义：运用共享技术来有効地支持大量细粒度对象的复用。它通过共享已经存在的又橡来大幅度减少需要创建的对象数量、避免大量相似类的开销，从而提高系统资源的利用率。
享元模式的主要优点是：相同对象只要保存一份，这降低了系统中对象的数量，从而降低了系统中细粒度对象给内存带来的压力。
其主要缺点是：
为了使对象可以共享，需要将一些不能共享的状态外部化，这将增加程序的复杂性。读取享元模式的外部状态会使得运行时间稍微变长。享元模式中存在以下两种状态：
内部状态，即不会随着环境的改变而改变的可共享部分；外部状态，指随环境改变而改变的不可以共享的部分。享元模式的实现要领就是区分应用中的这两种状态，并将外部状态外部化。下面来分析其基本结构和实现方法。模式的结构 享元模式的主要角色有如下。
抽象享元角色（Flyweight）:是所有的具体享元类的基类，为具体享元规范需要实现的公共接口，非享元的外部状态以参数的形式通过方法传入。具体享元（Concrete Flyweight）角色：实现抽象享元角色中所规定的接口。非享元（Unsharable Flyweight)角色：是不可以共享的外部状态，它以参数的形式注入具体享元的相关方法中。享元工厂（Flyweight Factory）角色：负责创建和管理享元角色。当客户对象请求一个享元对象时，享元工厂检査系统中是否存在符合要求的享元对象，如果存在则提供给客户；如果不存在的话，则创建一个新的享元对象。模式的实现
public class FlyweightPattern { public static void main(String[] args) { FlyweightFactory factory = new FlyweightFactory(); Flyweight f01 = factory.getFlyweight("a"); Flyweight f02 = factory.getFlyweight("a"); Flyweight f03 = factory.getFlyweight("a"); Flyweight f11 = factory.getFlyweight("b"); Flyweight f12 = factory.getFlyweight("b"); f01.operation(new UnsharedConcreteFlyweight("第1次调用a。")); f02.operation(new UnsharedConcreteFlyweight("第2次调用a。")); f03.operation(new UnsharedConcreteFlyweight("第3次调用a。")); f11.operation(new UnsharedConcreteFlyweight("第1次调用b。")); f12.operation(new UnsharedConcreteFlyweight("第2次调用b。")); } } //非享元角色 class UnsharedConcreteFlyweight { private String info; UnsharedConcreteFlyweight(String info) { this.info = info; } public String getInfo() { return info; } public void setInfo(String info) { this.info = info; } } //抽象享元角色 interface Flyweight { public void operation(UnsharedConcreteFlyweight state); } //具体享元角色 class ConcreteFlyweight implements Flyweight { private String key; ConcreteFlyweight(String key) { this.key = key; System.out.println("具体享元" + key + "被创建！"); } public void operation(UnsharedConcreteFlyweight outState) { System.out.print("具体享元" + key + "被调用，"); System.out.println("非享元信息是:" + outState.getInfo()); } } //享元工厂角色 class FlyweightFactory { private HashMap<String, Flyweight> flyweights = new HashMap<String, Flyweight>(); public Flyweight getFlyweight(String key) { Flyweight flyweight = (Flyweight) flyweights.get(key); if (flyweight != null) { System.out.println("具体享元" + key + "已经存在，被成功获取！"); } else { flyweight = new ConcreteFlyweight(key); flyweights.put(key, flyweight); } return flyweight; }享元模式在主要解决的对象的共享问题，如何建立多个可共享的细粒度对象则是其关注的重点。
组合（Composite）模式的定义：有时又叫作部分-整体模式，它是一种将对象组合成树状的层次结构的模式，用来表示“部分-整体”的关系，使用户对单个对象和组合对象具有一致的访问性。
组合模式的主要优点有：
组合模式使得客户端代码可以一致地处理单个对象和组合对象，无须关心自己处理的是单个对象，还是组合对象，这简化了客户端代码；更容易在组合体内加入新的对象，客户端不会因为加入了新的对象而更改源代码，满足“开闭原则”；其主要缺点是：
设计较复杂，客户端需要花更多时间理清类之间的层次关系；不容易限制容器中的构件；不容易用继承的方法来增加构件的新功能；模式的结构 组合模式包含以下主要角色。
抽象构件（Component）角色：它的主要作用是为树叶构件和树枝构件声明公共接口，并实现它们的默认行为。在透明式的组合模式中抽象构件还声明访问和管理子类的接口；在安全式的组合模式中不声明访问和管理子类的接口，管理工作由树枝构件完成。树叶构件（Leaf）角色：是组合中的叶节点对象，它没有子节点，用于实现抽象构件角色中 声明的公共接口。树枝构件（Composite）角色：是组合中的分支节点对象，它有子节点。它实现了抽象构件角色中声明的接口，它的主要作用是存储和管理子部件，通常包含Add()、Remove()、GetChild() 等方法。模式的实现
public class CompositePattern { public static void main(String[] args) { Component c0 = new Composite(); Component c1 = new Composite(); Component leaf1 = new Leaf("1"); Component leaf2 = new Leaf("2"); Component leaf3 = new Leaf("3"); c0.add(leaf1); c0.add(c1); c1.add(leaf2); c1.add(leaf3); c0.operation(); } } //抽象构件 interface Component { public void add(Component c); public void remove(Component c); public Component getChild(int i); public void operation(); } //树叶构件 class Leaf implements Component { private String name; public Leaf(String name) { this.name = name; } public void add(Component c) { } public void remove(Component c) { } public Component getChild(int i) { return null; } public void operation() { System.out.println("树叶" + name + "：被访问！"); } } //树枝构件 class Composite implements Component { private ArrayList<Component> children = new ArrayList<Component>(); public void add(Component c) { children.add(c); } public void remove(Component c) { children.remove(c); } public Component getChild(int i) { return children.get(i); } public void operation() { for (Object obj : children) { ((Component) obj).operation(); } } }前面分析了组合模式的结构与特点，下面分析它适用的以下应用场景。
在需要表示一个对象整体与部分的层次结构的场合。要求对用户隐藏组合对象与单个对象的不同，用户可以用统一的接口使用组合结构中的所有对象的场合。