标签：简洁 不同 扩展 运行 imm ant com 遍历 interface
除了Framework，5-2节所讨论的其他技术都过于“基础”和“细小”，有没有办法做更大规模的复用设计？
本节将介绍几种典型的“面向复用”的设计模式，设计模式更强调多个类/对象之间的关系和交互过程—比接口/类复用的粒度更大。
【适配器模式（Adapter）】
问题描述：其中LegacyRectangle是已有的类（需要传入矩形的一个顶点、长和宽），但是与client要求的接口不一致（需要给出对角线两个顶点坐标），我们此时建立一个新的接口Shape以供客户端调用，用户通过Shape接口传入两个点的坐标。Rectangle作为Adapter，实现该抽象接口，通过具体的方法实现适配。
在不适用适配器时：会发生委派不相容。
使用了适配器后就能够解决上述问题：
【装饰器模式（Decorator）】
我们需要一层层具有多种特征的object，通过一层层的装饰来实现：
Stack s = new ArrayStack(); //构建一个普通的堆栈 UndoStack s = new UndoStack(new ArrayStack()); //构建撤消堆栈 SecureStack s = new SecureStack( new SynchronizedStack( new UndoStack(s)))//构建安全的同步撤消堆栈
java.util.Collections中也有一些装饰器模式： static List<T> unmodifiableList(List<T> lst); static Set<T> unmodifiableSet( Set<T> set); static Map<K,V> unmodifiableMap( Map<K,V> map);
static List<T> synchronizedList(List<T> lst); static Set<T> synchronizedSet( Set<T> set); static Map<K,V> synchronizedMap( Map<K,V> map);
【外观模式（Facade Pattern）】
实例二：
假设我们有一个具有一组接口的应用程序来使用MySql / Oracle数据库，并生成不同类型的报告，如HTML报告，PDF报告等。
因此，我们将有不同的接口集合来处理不同类型的数据库。现在客户端应用程序可以使用这些接口来获取所需的数据库连接并生成报告。但是，当复杂性增加或界面行为名称混淆时，客户端应用程序将难以管理它。
因此，我们可以在这里应用Facade模式，并在现有界面的顶部提供包装界面以帮助客户端应用程序。
Two Helper Classes for MySQL and Oracle： 分别封装了客户端所需的功能
A fa?ade class:
客户端代码：
我们可以看到采用了Facade设计模式的客户端代码简洁了许多，更方便客户使用。
【策略模式（ Strategy）】
public interface CentralityStrategy { //对应上图的 Strategy<<interface>> public abstract centrality(); }
1 public class degreeCentralityStrategy<L extends Vertex, E extends Edge> implements CentralityStrategy { 2 3 private final Graph<L, E> g; 4 private final L v; 5 6 public degreeCentralityStrategy(Graph<L, E> g, L v) { 7 this.g = g; 8 this.v = v; 9 } 10 11 @Override 12 public double centrality() { 13 return GraphMetrics.degreeCentrality(g, v); 14 } 15 }
1 public class closenessCentralityStrategy<L extends Vertex, E extends Edge> implements CentralityStrategy { 2 3 private final Graph<L, E> g; 4 private final L v; 5 6 public closenessCentralityStrategy(Graph<L, E> g, L v) { 7 this.g = g; 8 this.v = v; 9 } 10 11 @Override 12 public double centrality() { 13 return GraphMetrics.closenessCentrality(g, v); 14 } 15 }
1 public class betweennessCentralityStrategy<L extends Vertex, E extends Edge> implements CentralityStrategy{ 2 3 private final Graph<L, E> g; 4 private final L v; 5 6 public betweennessCentralityStrategy(Graph<L, E> g, L v) { 7 this.g = g; 8 this.v = v; 9 } 10 11 @Override 12 public double centrality() { 13 return GraphMetrics.betweennessCentrality(g, v); 14 } 15 }
public class CentralityContext { public double centrality(CentralityStrategy centralityType) { return centralityType.centrality(); } }
1 public class Main { 2 3 public static void main(String[] args) { 4 5 Graph<Vertex, Edge> graph = GraphFactory.createGraph("test/graph/GraphPoetTest.txt"); 6 String[] strings = {"F", "24"}; 7 Vertex vertex1 = VertexFactory.createVertex("to", "Word", strings); 8 CentralityContext context = new CentralityContext(); 9 double degree = context.centrality(new DegreeCentralityStrategy<>(graph, vertex1)); 10 double closeness = context.centrality(new ClosenessCentralityStrategy<>(graph, vertex1)); 11 double betweenness = context.centrality(new BetweennessCentralityStrategy<>(graph, vertex1)); 12 System.out.println(degree); 13 System.out.println(closeness); 14 System.out.println(betweenness); 15 } 16 }
【模板模式（Template method）】
1 public abstract class Edge { 2 3 private final String label; 4 private final double weight; 5 6 //the constructor 7 public Edge(String label, double weight) { 8 this.label = label; 9 this.weight = weight; 10 } 11 12 public abstract boolean addVertices(List<Vertex> vertices); 13 14 public abstract boolean containVertex(Vertex v); 15 16 public abstract Set<Vertex> vertices();
1 public class DirectedEdge extends Edge{ 2 3 private Vertex source; 4 private Vertex target; 5 6 //the constructor 7 public DirectedEdge(String label, double weight) { 8 super(label, weight); 9 } 10 11 @Override 12 public boolean addVertices(List<Vertex> vertices) { 13 source = vertices.get(0); 14 target = vertices.get(1); 15 return true; 16 } 17 18 @Override 19 public boolean containVertex(Vertex v) { 20 return source.equals(v) || target.equals(v); 21 } 22 23 @Override 24 public Set<Vertex> vertices() { 25 Set<Vertex> set = new HashSet<Vertex>(); 26 set.add(source); 27 set.add(target); 28 return set; 29 }
1 public class UndirectedEdge extends Edge{ 2 3 private Vertex vertex1; 4 private Vertex vertex2; 5 6 public UndirectedEdge(String label, double weight) { 7 super(label, weight); 8 } 9 10 @Override 11 public boolean addVertices(List<Vertex> vertices) { 12 vertex1 = vertices.get(0); 13 vertex2 = vertices.get(1); 14 return true; 15 } 16 17 @Override 18 public boolean containVertex(Vertex v) { 19 return vertex1.equals(v) || vertex2.equals(v); 20 } 21 22 @Override 23 public Set<Vertex> vertices() { 24 Set<Vertex> set = new HashSet<Vertex>(); 25 set.add(vertex1); 26 set.add(vertex2); 27 return set; 28 }
【迭代器模式（ Iterator）】
Iterable接口，并实现自己的独特Iterator迭代器(hasNext, next, remove），允许客户端利用这 个迭代器进行显式或隐式的迭代遍历。
Iterable接口：实现该接口的集合对象是可迭代遍历的
public interface Iterable<T> { ... Iterator<T> iterator(); }
Iterator接口：迭代器
public interface Iterator<E> { boolean hasNext(); E next(); void remove(); }
标签：简洁 不同 扩展 运行 imm ant com 遍历 interface
原文地址：https://www.cnblogs.com/hithongming/p/9189696.html
