设计模式之布局型模式

一、布局型模式概述

布局型模式主要用于处置处罚类与对象的组合。它形貌了怎样将类或对象结合在一起形成更大的布局，就像搭积木一样，通过不同的组合方式构建出复杂而强盛的软件架构。其主要目的是简化体系的设计，提高体系的灵活性、可维护性和可扩展性。常见的布局型模式有署理模式、适配器模式、桥接模式、装饰器模式、外观模式、享元模式和组合模式。
二、署理模式

（一）定义与概念

署理模式是为其他对象提供一种署理以控制对这个对象的访问。在某些情况下，一个对象不得当或者不能直接引用另一个对象，而署理对象可以在客户端和目的对象之间起到中介的作用。
（二）关键要点

• 控制访问：署理模式可以在访问目的对象之前进行权限检查、日志纪录等操作，对目的对象的访问进行控制。
  

• 延迟加载：当目的对象创建开销较大时，可以通过署理模式实现延迟加载，只有在真正需要时才创建目的对象。
  

（三）代码示例

1. // 抽象主题接口
3. interface Subject {
5. void request();
7. }
9. // 真实主题类
11. class RealSubject implements Subject {
13. @Override
15. public void request() {
17. System.out.println("真实主题执行请求");
19. }
21. }
23. // 代理类
25. class Proxy implements Subject {
27. private RealSubject realSubject;
29. @Override
31. public void request() {
33. if (realSubject == null) {
35. realSubject = new RealSubject();
37. }
39. // 访问前的额外操作，如日志记录
41. System.out.println("代理记录访问日志");
43. realSubject.request();
45. }
47. }

复制代码

在上述代码中，Proxy类署理了RealSubject类，在调用request方法时，先进行了日志纪录操作，然后再调用真实主题的request方法。
三、适配器模式

（一）定义与概念

适配器模式将一个类的接口转换成客户希望的另外一个接口。适配器模式使得原来由于接口不兼容而不能一起工作的那些类可以一起工作。
（二）关键要点

• 接口转换：解决不兼容接口之间的适配问题，是一种补救模式。
  

• 类适配器和对象适配器：类适配器通过继续实现，对象适配器通过组合实现，在实际应用中可根据具体情况选择合适的方式。
  

（三）代码示例

1. // 目标接口
3. interface Target {
5. void request();
7. }
9. // 适配者类
11. class Adaptee {
13. public void specificRequest() {
15. System.out.println("适配者执行特定请求");
17. }
19. }
21. // 类适配器
23. class ClassAdapter extends Adaptee implements Target {
25. @Override
27. public void request() {
29. specificRequest();
31. }
33. }
35. // 对象适配器
37. class ObjectAdapter implements Target {
39. private Adaptee adaptee;
41. public ObjectAdapter(Adaptee adaptee) {
43. this.adaptee = adaptee;
45. }
47. @Override
49. public void request() {
51. adaptee.specificRequest();
53. }
55. }

复制代码

在这个例子中，ClassAdapter通过继续Adaptee类实现了Target接口，ObjectAdapter则通过组合Adaptee对象实现了Target接口，两者都将Adaptee的specificRequest方法适配成了Target接口的request方法。
四、桥接模式

（一）定义与概念

桥接模式将抽象部分与它的实现部分分离，使它们都可以独立地变化。它是一种对象布局型模式，通过将抽象和实现解耦，使得两者可以沿着各自的维度进行扩展。
（二）关键要点

• 解耦抽象与实现：避免了抽象和实现的紧耦合，提高了体系的可维护性和可扩展性。
  

• 多维度变化：允许抽象和实现分别独立地进行变化，适用于体系中存在多个变化维度的情况。
  

（三）代码示例

1. // 抽象实现类接口
3. interface Implementor {
5. void operationImpl();
7. }
9. // 具体实现类A
11. class ConcreteImplementorA implements Implementor {
13. @Override
15. public void operationImpl() {
17. System.out.println("具体实现类A的操作");
19. }
21. }
23. // 具体实现类B
25. class ConcreteImplementorB implements Implementor {
27. @Override
29. public void operationImpl() {
31. System.out.println("具体实现类B的操作");
33. }
35. }
37. // 抽象类
39. abstract class Abstraction {
41. protected Implementor implementor;
43. public Abstraction(Implementor implementor) {
45. this.implementor = implementor;
47. }
49. public abstract void operation();
51. }
53. // 扩充抽象类
55. class RefinedAbstraction extends Abstraction {
57. public RefinedAbstraction(Implementor implementor) {
59. super(implementor);
61. }
63. @Override
65. public void operation() {
67. System.out.println("扩充抽象类开始操作");
69. implementor.operationImpl();
71. System.out.println("扩充抽象类操作结束");
73. }
75. }

复制代码

在上述代码中，Abstraction类与Implementor接口通过构造函数进行关联，实现了抽象与实现的分离。RefinedAbstraction类可以根据不同的Implementor实现类进行不同的操作，体现了桥接模式的灵活性。
五、装饰器模式

（一）定义与概念

装饰器模式动态地给一个对象添加一些额外的职责。就增加功能来说，装饰器模式相比天生子类更为灵活。
（二）关键要点

• 动态添加功能：无需修改原有类的代码，通过装饰器类为对象动态添加功能。
  

• 多层装饰：可以对一个对象进行多层装饰，以实现复杂的功能组合。
  

（三）代码示例

2. // 抽象组件
4. abstract class Component {
6. public abstract void operation();
8. }
10. // 具体组件
12. class ConcreteComponent extends Component {
14. @Override
16. public void operation() {
18. System.out.println("具体组件的操作");
20. }
22. }
24. // 抽象装饰器
26. abstract class Decorator extends Component {
28. protected Component component;
30. public Decorator(Component component) {
32. this.component = component;
34. }
36. @Override
38. public void operation() {
40. component.operation();
42. }
44. }
46. // 具体装饰器A
48. class ConcreteDecoratorA extends Decorator {
50. public ConcreteDecoratorA(Component component) {
52. super(component);
54. }
56. @Override
58. public void operation() {
60. super.operation();
62. // 添加额外功能
64. System.out.println("具体装饰器A添加的功能");
66. }
68. }
70. // 具体装饰器B
72. class ConcreteDecoratorB extends Decorator {
74. public ConcreteDecoratorB(Component component) {
76. super(component);
78. }
80. @Override
82. public void operation() {
84. super.operation();
86. // 添加额外功能
88. System.out.println("具体装饰器B添加的功能");
90. }
92. }

复制代码

在这个例子中，ConcreteDecoratorA和ConcreteDecoratorB可以为ConcreteComponent动态添加不同的功能，而且可以进行多层装饰，如先使用ConcreteDecoratorA装饰，再使用ConcreteDecoratorB装饰。
六、外观模式

（一）定义与概念

外观模式为子体系中的一组接口提供一个一致的界面，此模式定义了一个高层接口，这个接口使得这一子体系更加轻易使用。
（二）关键要点

• 简化接口：将复杂的子体系接口封装成一个简单的统一接口，低沉客户端与子体系的耦合度。
  

• 解耦：客户端只需要与外观类交互，而不需要了解子体系内部的复杂布局和交互细节。
  

（三）代码示例

1. // 子系统类A
3. class SubsystemA {
5. public void operationA() {
7. System.out.println("子系统A的操作");
9. }
11. }
13. // 子系统类B
15. class SubsystemB {
17. public void operationB() {
19. System.out.println("子系统B的操作");
21. }
23. }
25. // 子系统类C
27. class SubsystemC {
29. public void operationC() {
31. System.out.println("子系统C的操作");
33. }
35. }
37. // 外观类
39. class Facade {
41. private SubsystemA subsystemA;
43. private SubsystemB subsystemB;
45. private SubsystemC subsystemC;
47. public Facade() {
49. subsystemA = new SubsystemA();
51. subsystemB = new SubsystemB();
53. subsystemC = new SubsystemC();
55. }
57. public void operation() {
59. subsystemA.operationA();
61. subsystemB.operationB();
63. subsystemC.operationC();
65. }
67. }

复制代码

在上述代码中，Facade类封装了SubsystemA、SubsystemB和SubsystemC的操作，客户端只需要调用Facade的operation方法，就可以实行一系列子体系的操作，而无需了解子体系内部的具体实现。
七、享元模式

（一）定义与概念

享元模式运用共享技术有效地支持大量细粒度的对象。通过共享已经存在的对象来大幅度减少需要创建的对象数量，避免大量相似类的开销。
（二）关键要点

• 对象共享：通过共享对象来减少内存占用和提高性能，适用于大量重复对象的场景。
  

• 内部状态和外部状态：将对象的状态分为内部状态（不随情况改变而改变的可共享部分）和外部状态（随情况改变而改变的不可共享部分），在共享对象时，只共享内部状态。
  

（三）代码示例

1. // 抽象享元类
3. abstract class Flyweight {
5. protected String intrinsicState;
7. public Flyweight(String intrinsicState) {
9. this.intrinsicState = intrinsicState;
11. }
13. public abstract void operation(String extrinsicState);
15. }
17. // 具体享元类
19. class ConcreteFlyweight extends Flyweight {
21. public ConcreteFlyweight(String intrinsicState) {
23. super(intrinsicState);
25. }
27. @Override
29. public void operation(String extrinsicState) {
31. System.out.println("具体享元对象的内部状态：" + intrinsicState + "，外部状态：" + extrinsicState);
33. }
35. }
37. // 享元工厂类
39. class FlyweightFactory {
41. private Map<String, Flyweight> flyweights = new HashMap<>();
43. public Flyweight getFlyweight(String intrinsicState) {
45. if (!flyweights.containsKey(intrinsicState)) {
47. flyweights.put(intrinsicState, new ConcreteFlyweight(intrinsicState));
49. }
51. return flyweights.get(intrinsicState);
53. }
55. }

复制代码

在这个例子中，FlyweightFactory类负责创建和管理享元对象，通过共享ConcreteFlyweight对象，减少了对象的创建数量。
八、组合模式

（一）定义与概念

组合模式将对象组合成树形布局以表现 “部分 - 团体” 的条理布局。组合模式使得用户对单个对象和组合对象的使用具有一致性。
（二）关键要点

• 树形布局：用于表现对象的条理布局，方便对整个树或部分树进行操作。
  

• 统一操作：客户端可以统一地使用组合对象和单个对象，无需区分它们。
  

（三）代码示例

1. // 抽象组件
3. abstract class Component {
5. protected String name;
7. public Component(String name) {
9. this.name = name;
11. }
13. public abstract void add(Component component);
15. public abstract void remove(Component component);
17. public abstract void display(int depth);
19. }
21. // 叶子节点
23. class Leaf extends Component {
25. public Leaf(String name) {
27. super(name);
29. }
31. @Override
33. public void add(Component component) {
35. System.out.println("叶子节点不能添加子节点");
37. }
39. @Override
41. public void remove(Component component) {
43. System.out.println("叶子节点不能移除子节点");
45. }
47. @Override
49. public void display(int depth) {
51. for (int i = 0; i < depth; i++) {
53. System.out.print("-");
55. }
57. System.out.println("Leaf: " + name);
59. }
61. }
63. // 组合节点
65. class Composite extends Component {
67. private List<Component> children = new ArrayList<>();
69. public Composite(String name) {
71. super(name);
73. }
75. @Override
77. public void add(Component component) {
79. children.add(component);
81. }
83. @Override
85. public void remove(Component component) {
87. children.remove(component);
89. }
91. @Override
93. public void display(int depth) {
95. for (int i = 0; i < depth; i++) {
97. System.out.print("-");
99. }
101. System.out.println("Composite: " + name);
103. for (Component component : children) {
105. component.display(depth + 2);
107. }
109. }
111. }

复制代码

在上述代码中，Composite类可以包罗多个Component对象（包括Leaf和Composite），形成树形布局。客户端可以统一地对Leaf和Composite进行操作，如添加、移除和显示等。



免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。