计划模式之布局型模式

在软件开发的天下里，计划模式是先辈们智慧的结晶，它们为我们提供了通用的解决方案来应对各种常见的软件计划问题。本日，我们深入探究计划模式中的布局型模式，并用 Java 语言来实现它们。
什么是布局型模式

布局型模式主要关注怎样将类或对象组合成更大的布局，以实现更复杂的功能。它就像是搭建积木，通过不同的组合方式，让简单的组件发挥出强盛的作用。布局型模式可以分为类布局型模式和对象布局型模式，前者主要通过继承机制来组合类，后者则通过对象的组合来实现。
常见的布局型模式

署理模式（Proxy Pattern）

关键要点：署理模式为其他对象提供一种署理以控制对这个对象的访问。当无法或不想直接访问某个对象时，署理对象可以代替目标对象举行工作。
代码示例：

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. public Proxy(RealSubject realSubject) {
31. this.realSubject = realSubject;
33. }
35. @Override
37. public void request() {
39. // 可以在调用真实主题前后进行额外操作
41. System.out.println("代理预处理");
43. realSubject.request();
45. System.out.println("代理后处理");
47. }
49. }

复制代码

利用示例：

1. public class ProxyPatternExample {
3. public static void main(String[] args) {
5. RealSubject realSubject = new RealSubject();
7. Proxy proxy = new Proxy(realSubject);
9. proxy.request();
11. }
13. }

复制代码

适配器模式（Adapter Pattern）

关键要点：将一个类的接口转换成客户盼望的另一个接口。适配器模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。
代码示例：

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 Adapter implements Target {
25. private Adaptee adaptee;
27. public Adapter(Adaptee adaptee) {
29. this.adaptee = adaptee;
31. }
33. @Override
35. public void request() {
37. adaptee.specificRequest();
39. }
41. }

复制代码

利用示例：

1. public class AdapterPatternExample {
3. public static void main(String[] args) {
5. Adaptee adaptee = new Adaptee();
7. Target target = new Adapter(adaptee);
9. target.request();
11. }
13. }

复制代码

桥接模式（Bridge Pattern）

关键要点：将抽象部门与它的实现部门分离，使它们都可以独立地变化。它是一种对象布局型模式，通过将接口和实现分离，让它们可以独立扩展。
代码示例：

1. // 抽象化角色
3. abstract class Abstraction {
5. protected Implementor implementor;
7. public Abstraction(Implementor implementor) {
9. this.implementor = implementor;
11. }
13. public abstract void operation();
15. }
17. // 扩充抽象化角色
19. class RefinedAbstraction extends Abstraction {
21. public RefinedAbstraction(Implementor implementor) {
23. super(implementor);
25. }
27. @Override
29. public void operation() {
31. implementor.operationImpl();
33. }
35. }
37. // 实现化角色
39. interface Implementor {
41. void operationImpl();
43. }
45. // 具体实现化角色
47. class ConcreteImplementorA implements Implementor {
49. @Override
51. public void operationImpl() {
53. System.out.println("具体实现A的操作");
55. }
57. }

复制代码

利用示例：

1. public class BridgePatternExample {
3. public static void main(String[] args) {
5. Implementor implementor = new ConcreteImplementorA();
7. Abstraction abstraction = new RefinedAbstraction(implementor);
9. abstraction.operation();
11. }
13. }

复制代码

装饰器模式（Decorator Pattern）

关键要点：动态地给一个对象添加一些额外的职责。就增加功能来说，装饰器模式相比生成子类更为机动。
代码示例：

1. // 组件接口
3. interface Component {
5. void operation();
7. }
9. // 具体组件
11. class ConcreteComponent implements Component {
13. @Override
15. public void operation() {
17. System.out.println("具体组件执行操作");
19. }
21. }
23. // 装饰器抽象类
25. abstract class Decorator implements Component {
27. protected Component component;
29. public Decorator(Component component) {
31. this.component = component;
33. }
35. @Override
37. public void operation() {
39. component.operation();
41. }
43. }
45. // 具体装饰器
47. class ConcreteDecoratorA extends Decorator {
49. public ConcreteDecoratorA(Component component) {
51. super(component);
53. }
55. @Override
57. public void operation() {
59. super.operation();
61. System.out.println("具体装饰器A添加的额外操作");
63. }
65. }

复制代码

利用示例：

1. public class DecoratorPatternExample {
3. public static void main(String[] args) {
5. Component component = new ConcreteComponent();
7. Component decoratedComponent = new ConcreteDecoratorA(component);
9. decoratedComponent.operation();
11. }
13. }

复制代码

外观模式（Facade Pattern）

关键要点：为子体系中的一组接口提供一个一致的界面，外观模式定义了一个高层接口，这个接口使得这一子体系更加容易利用。
代码示例：

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. // 外观类
27. class Facade {
29. private SubSystemA subSystemA;
31. private SubSystemB subSystemB;
33. public Facade() {
35. subSystemA = new SubSystemA();
37. subSystemB = new SubSystemB();
39. }
41. public void operation() {
43. subSystemA.operationA();
45. subSystemB.operationB();
47. }
49. }

复制代码

利用示例：

1. public class FacadePatternExample {
3. public static void main(String[] args) {
5. Facade facade = new Facade();
7. facade.operation();
9. }
11. }

复制代码

享元模式（Flyweight Pattern）

关键要点：运用共享技术有效地支持大量细粒度的对象。通过共享已经存在的对象来大幅度减少需要创建的对象数量、避免大量相似类的开销，从而进步体系资源的利用率。
代码示例：

1. // 享元工厂类
3. class FlyweightFactory {
5. private static final Map<String, Flyweight> flyweights = new HashMap<>();
7. public static Flyweight getFlyweight(String key) {
9. if (!flyweights.containsKey(key)) {
11. flyweights.put(key, new ConcreteFlyweight(key));
13. }
15. return flyweights.get(key);
17. }
19. }
21. // 享元接口
23. interface Flyweight {
25. void operation(String extrinsicState);
27. }
29. // 具体享元类
31. class ConcreteFlyweight implements Flyweight {
33. private final String intrinsicState;
35. public ConcreteFlyweight(String intrinsicState) {
37. this.intrinsicState = intrinsicState;
39. }
41. @Override
43. public void operation(String extrinsicState) {
45. System.out.println("内在状态：" + intrinsicState + "，外在状态：" + extrinsicState);
47. }
49. }
51. 使用示例：
54. public class FlyweightPatternExample {
56. public static void main(String[] args) {
58. Flyweight flyweight1 = FlyweightFactory.getFlyweight("key1");
60. flyweight1.operation("extrinsic1");
62. Flyweight flyweight2 = FlyweightFactory.getFlyweight("key1");
64. flyweight2.operation("extrinsic2");
66. }
68. }

复制代码

组合模式（Composite Pattern）

关键要点：将对象组合成树形布局以表示 “部门 - 团体” 的条理布局。组合模式使得用户对单个对象和组合对象的利用具有一致性。
代码示例：

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. }

复制代码

利用示例：

1. public class CompositePatternExample {
3. public static void main(String[] args) {
5. Composite root = new Composite("root");
7. root.add(new Leaf("Leaf A"));
9. root.add(new Leaf("Leaf B"));
11. Composite comp = new Composite("Composite X");
13. comp.add(new Leaf("Leaf XA"));
15. comp.add(new Leaf("Leaf XB"));
17. root.add(comp);
19. root.display(1);
21. }
23. }

复制代码

总结

布局型模式为我们在软件计划中构建复杂布局提供了有力的工具。通过合理运用这些模式，可以进步代码的可维护性、可扩展性和可复用性。在实际项目中，根据具体的需求选择合适的布局型模式，能够让我们的代码更加优雅、高效。盼望这篇文章能资助你更好地明白和运用计划模式中的布局型模式。

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