Recomendados
Mais conteúdo relacionado
Mais procurados
Mais procurados (20)
Semelhante a 组合、备忘录、建造者模式、原型
Semelhante a 组合、备忘录、建造者模式、原型 (20)
Mais de 诸葛修车网-诸葛商城
组合、备忘录、建造者模式、原型
- 1. 设计模式 - 组合 （ composite ）模式
- 2. 组合模式 模式动机与定义 模式结构与分析 模式实例与解析 模式效果与应用 模式扩展
- 5. 模式定义 组合模式 (Composite Pattern) ：组合多个 对象形成树形结构以表示“整体—部分”的 结构层次。组合模式对单个对象（即叶子 对象）和组合对象（即容器对象）的使用 具有一致性。 组合模式又可以称为“整体—部分” (Part- Whole) 模式，属于对象的结构模式，它将 对象组织到树结构中，可以用来描述整体 与部分的关系。
- 6. 模式结构 children Client Component + + + + operation () add (Component c) remove (Component c) getChild (int i) ... Leaf + operation () ... Composite + + + + operation () add (Component c) remove (Component c) getChild (int i) ... for(Component child:children) { child.operation(); }
- 7. 模式结构 组合模式包含如下角色： Component: 抽象构件 Leaf: 叶子构件 Composite: 容器构件 Client: 客户类
- 9. 文件系统组合模式结构图 list AbstractElement {abstract} + + + + add (AbstractElement element) remove (AbstractElement element) get (int i) method () ... : void : void : AbstractElement : void File + method () ... : void Folder - list : AbstractElement[] + + + + add (AbstractElement element) remove (AbstractElement element) get (int i) method () ... : void : void : AbstractElement : void
- 10. 叶子节点的代码
- 11. 容器构件角色代码
- 13. 组合模式实例 文件浏览 fileList AbstractFile {abstract} + + + add (AbstractFile element) remove (AbstractFile element) display () ... : void : void : void ImageFile - fileName : String + + + + ImageFile (String fileName) add (AbstractFile element) remove (AbstractFile element) display () ... : void : void : void Folder - - fileList fileName : ArrayList : String + + + + Folder (String fileName) add (AbstractFile element) remove (AbstractFile element) display () ... : void : void : void TextFile - fileName : String + + + + TextFile (String fileName) add (AbstractFile element) remove (AbstractFile element) display () ... : void : void : void VideoFile - fileName : String + + + + VideoFile (String fileName) add (AbstractFile element) remove (AbstractFile element) display () ... : void : void : void
- 14. 模式优缺点 组合模式的优点如下： 可以清楚地定义分层次的复杂对象， 表示对象的全部或部分层次，使得增 加新构件也更容易。 客户端调用简单，客户端可以一致的 使用组合结构或其中单个对象。
- 17. 模式适用环境 在以下情况下可以使用组合模式： 需要表示一个对象整体或部分层次，在具有整体 和部分的层次结构中，希望通过一种方式忽略整 体与部分的差异，可以一致地对待它们。 让客户能够忽略不同对象层次的变化，客户端可 以针对抽象构件编程，无需关心对象层次结构的 细节。 对象的结构是动态的并且复杂程度不一样，但客 户需要一致地处理它们。
- 18. XML 文档解析 <?xml version="1.0"?> <books> <book> <author>Carson</author> <price format="dollar">31.95</price> <pubdate>05/01/2001</pubdate> </book> <pubinfo> <publisher>MSPress</publisher> <state>WA</state> </pubinfo> </books>
- 20. 模式应用 JDK 的 AWT/Swing 是组合模式在 Java 类库中的一个 典型实际应用。 component Component Button Container - component : Component[] TextComponentCheckbox
- 23. 备忘录模式 忘 模式概述备 录 忘 模式的 与备 录 结构 实现 忘 模式的 用 例备 录 应 实 多次撤实现 销 忘 模式的 缺点与适用 境备 录 优 环
- 26. 备忘录模式的定义
- 27. 备忘录模式 提供了一种状态恢复的实现机制，使得用户 可以方便地回到一个特定的历史步骤 当前在很多软件所提供的撤销 (Undo) 操作 中就使用了备忘录模式
- 28. 备忘录模式的结构 mementoreturn new Memento(state); Originator - state : + + RestoreMemento (Memento m) CreateMemento () ... Memento - state : + + GetState () SetState ( state) ... Caretaker state=m.GetState();
- 29. 备忘录模式的结构 备忘录模式包含以下 3 个角色： • Originator （发起人） : 记录当前时刻的内部状 态，负责定义哪些属于备份范围的状态，负责创 建和恢复备忘录数据。 • Memento （备忘录 ): 负责存储发起人对象的内 部状态，在需要的时候提供发起人需要的内部状 态。 • Caretaker （负责人） : 对备忘录进行管理，保 存和提供备忘录。
- 30. 动机 有时候用户需要撤销多步操作 实现方案：在负责人类中定义一个集合来存 储多个备忘录，每个备忘录负责保存一个历 史状态，在撤销时可以对备忘录集合进行逆 向遍历，回到一个指定的历史状态，还可以 对备忘录集合进行正向遍历，实现重做 (Redo) 或恢复操作，即取消撤销，让对象 状态得到恢复
- 31. 备忘录模式的优缺点 模式优点 提供了一种状态恢复的实现机制，使得用户 可以方便地回到一个特定的历史步骤 实现了对信息的封装，一个备忘录对象是一 种原发器对象状态的表示，不会被其他代码 所改动
- 34. 建造者模式
- 39. 建造者模式的意图和适用性 以下情况可以使用建造者模式： 1. 需要生成的产品对象有复杂的内部结 构。 2. 创建复杂对象的算法稳定，或建造者 模式可以强迫生成一定的顺序。 3. 当构造过程允许被构造的对象有不同 的表示时。
- 40. 建造者模式结构图
- 41. 建造者模式的结构和参与者 1 ） Builder 为创建一个 Product 对象的各个部件指定抽象接口。 2 ） ConcreteBuilder 实现 Builder 的接口以构造和装配该产品的各个部件。 定义并明确它所创建的表示。 提供一个检索产品的接口 3 ） Director 构造一个使用 Builder 接口的对象。 4 ） Product 表示被构造的复杂对象。 ConcreteBuilder 创建该产品的内部表 示并定义它的装配过程。 包含定义组成部件的类，包括将这些部件装配成最终产品的接口 。
- 42. 设计游戏场景中的房屋 假设房屋由五个部分组成：地板、墙壁 、窗户、门和天花板。 构建一个房屋的步骤是一定的，而具体 的组件（门、窗等）是易变的。 采用建造者模式分离易变组件和稳定的 构建过程。
- 44. 优缺点 1. 建造者模式的使用使得产品的内部表象可以独立的变化。使用 建造者模式可以使客户端不必知道产品内部组成的细节。 2. 每一个 Builder 都相对独立，而与其它的 Builder 无关。 可使对构造过程更加精细控制。 4. 将构建代码和表示代码分开。 5. 建造者模式的缺点在于难于应付“分步骤构建算法”的需求变动 ( 如果创建算法总是变化就不适用了 ) 。
- 45. 设计模式 – 原型（ Prototype ）模式
- 47. 1 ， Java 对原型模式的支持 在 Java 里面，我们可以通过 Clone() 方法实现原型模式。任何类 ，只要想支持克隆，必须实现 Cloneable 接口。 Cloneable 接口 中有 Clone 方法，可以在类中复写实现自定义的克隆方法。克隆 的实现方法有三种：浅拷贝、深拷贝和完全拷贝。 (1) 浅拷贝 被拷贝对象的所有变量都含有与原来的对象相同的值，而所有的对 其他对象的引用仍然指向原来的对象。换言之，浅拷贝仅仅拷贝所 考虑的对象，而不拷贝它所引用的对象。 (2) 深拷贝 被拷贝对象的所有变量都含有与原来的对象相同的值，除去那些 引用其他对象的变量。那些引用其他对象的变量将指向被拷贝过的 新对象，而不再是原有的那些被引用的对象。换言之，深拷贝把要 拷贝的对象所引用的对象都拷贝了一遍。 (3) 完全拷贝 完全拷贝不仅把要拷贝的对象所直接引用的对象都拷贝了一遍， 还把该对象间接引用到的所有对象也都拷贝了一遍。这是最彻底的 一种拷贝。
- 48. 2 ， Java 的 clone() 方法 Clone protected Object clone() throws CloneNotSupportedException This method may be called to create a new copy of the Object. The typical behavior is as follows: o == o.clone() is false o.getClass() == o.clone().getClass() is true o.equals(o) is true However, these are not strict requirements, and may be violated if necessary. Of the three requirements, the last is the most commonly violated, particularly if the subclass does not override equals(Object) 55 . If the Object you call clone() on does not implement Cloneable (which is a placeholder interface), then a CloneNotSupportedException is thrown. Notice that Object does not implement Cloneable; this method exists as a convenience for subclasses that do. Object's implementation of clone allocates space for the new Object using the correct class, without calling any constructors, and then fills in all of the new field values with the old field values. Thus, it is a shallow copy. However, subclasses are permitted to make a deep copy. All array types implement Cloneable, and override this method as follows (it should never fail): public Object clone() { try { super.clone(); } catch (CloneNotSupportedException e) { throw new InternalError(e.getMessage()); } }
- 49. 2 ， Java 的 clone() 方法 ⑴clone 方法将对象复制了一份并返回给调用者。一 般而言， clone （）方法满足： ① 对任何的对象 x ，都有 x.clone() !=x 克隆对象与原对象不是同一个对象 ② 对任何的对象 x ，都有 x.clone().getClass()==x.getClass() 克隆对象与原对象的类型一样 ③ 如果对象 x 的 equals() 方法定义恰当，那么 x.clone().equals(x) 应该成立。 ⑵Java 中对象的克隆 ① 为了获取对象的一份拷贝，我们可以利用 Object 类的 clone() 方法。 ② 在派生类中覆盖基类的 clone() 方法，并声明为 public 。 ③ 在派生类的 clone() 方法中，调用 super.clone() 。
- 50. 3 ， Java 的类拷贝实现代码 class Student implements Cloneable { String name; int age; Student(String name,int age) { this.name=name; this.age=age; } public Object clone() { Object o=null; try { o=(Student)super.clone();//Object 中的 clone() 识别出你要复制的是哪一个对象。 } catch(CloneNotSupportedException e) { System.out.println(e.toString()); } return o; } } public static void main(String[] args) { Student s1=new Student(“zhangsan”,18); Student s2=(Student)s1.clone(); s2.name=“lisi”; s2.age=20; System.out.println(“name=”+s1.name+“,”+“age=”+s1.age);// 修改学生 2 后，不影响学生 1 的值。 } ① 为什么我们在派生类中覆盖 Object 的 clone() 方法时， 一定要调用 super.clone() 呢？在运行时刻， Object 中的 clone() 识别出你要复制的是哪一个对象，然后为此对象 分配空间，并进行对象的复制，将原始对象的内容一一 复制到新对象的存储空间中。 ②继承自 java.lang.Object 类的 clone() 方法是浅复制。 后面的代码可以证明。 浅拷贝
- 51. 3 ， Java 的类拷贝实现代码 class Professor { String name; int age; Professor(String name,int age) { this.name=name; this.age=age; } } class Student implements Cloneable { String name;// 常量对象。 int age; Professor p;// 学生 1 和学生 2 的引用值都是 一样的。 Student(String name,int age,Professor p) { this.name=name; this.age=age; this.p=p; } public Object clone() { Student o=null; try { o=(Student)super.clone(); } catch(CloneNotSupportedException e) { System.out.println(e.toString()); } //o.p=(Professor)p.clone(); return o; } } public static void main(String[] args) { Professor p=new Professor("wanGWu",50); Student s1=new Student("zhangsan",18,p); Student s2=(Student)s1.clone(); s2.p.name="lisi"; s2.p.age=30; System.out.println("name="+s1.p.name+","+"age ="+s1.p.age); // 学生 1 的教授为 lisi,age 为 30, 被改了 } 浅拷贝
- 52. 3 ， Java 的类拷贝实现代码 class Professor implements Cloneable { String name; int age; Professor(String name,int age) { this.name=name; this.age=age; } public Object clone() { Object o=null; try { o=super.clone(); } catch(CloneNotSupportedException e) { System.out.println(e.toString()); } return o; } } class Student implements Cloneable { String name;// 常量对象。 int age; Professor p;// 学生 1 和学生 2 的引用值都是 一样的。 Student(String name,int age,Professor p) { this.name=name; this.age=age; this.p=p; } public Object clone() { Student o=null; try { o=(Student)super.clone(); } catch(CloneNotSupportedException e) { System.out.println(e.toString()); } o.p=(Professor)p.clone(); return o; } } public static void main(String[] args) { Professor p=new Professor(“wanGWu”,50); Student s1=new Student(“zhangsan”,18,p); Student s2=(Student)s1.clone(); s2.p.name=“lisi”; s2.p.age=30; System.out.println(“name=”+s1.p.name+“,”+“age =”+s1.p.age);// 学生 1 的教授不改变 } 深拷贝
- 53. 3 ， Java 的类拷贝实现代码 class Professor implements Serializable { String name; int age; Professor(String name,int age) { this.name=name; this.age=age; } } class Student implements Serializable { String name;// 常量对象。 int age; Professor p;// 学生 1 和学生 2 的引用值都是一样的。 Student(String name,int age,Professor p) { this.name=name; this.age=age; this.p=p; } public Object fullClone() throws IOException, OptionalDataException,ClassNotFoundException { // 将对象写到流里 ByteArrayOutoutStream bo=new ByteArrayOutputStream(); ObjectOutputStream oo=new ObjectOutputStream(bo); oo.writeObject(this); // 从流里读出来 ByteArrayInputStream bi=new ByteArrayInputStream(bo.toByteArray()); ObjectInputStream oi=new ObjectInputStream(bi); return(oi.readObject()); } public static void main(String[] args) { Professor p=new Professor("wangwu",50); Student s1=new Student("zhangsan",18,p); Student s2=(Student)s1.fullClone(); s2.p.name="lisi"; s2.p.age=30; System.out.println("name="+s1.p.name+","+"age ="+s1.p.age); // 学生 1 的教授不改变。 完全拷贝 在 Java 语言里深复制一个对象，常常可以先使对象实现 Serializable 接口，然后把对象（实际上只是对象的一个拷贝） 写到一个流里（腌成干菜），再从流里读出来（把干菜回鲜），便可以重建对象。
- 54. 4 ， Prototype 模式的结构 客户（ Client ）角色： 客户类提出创建对象的请求。 抽象原型（ Prototype ）角色： 这是一个抽象角色，通常由一个接口类或抽象类实现。此角色给出所有的具体原型 类所需的接口。在 Java 中，抽象原型角色通常实现了 Cloneable 接口。 具体原型（ Concrete Prototype ）角色： 被复制的对象。此角色需要实现抽象原型角色所要求的接口。
- 55. 4.1 Prototype 模式实现 - 抽象原型 public abstract class AbstractSpoon implements Cloneable { String spoonName; public void setSpoonName(String spoonName) { this.spoonName = spoonName; } public String getSpoonName() {return this.spoonName;} public Object clone() { Object object = null; try { object = super.clone(); } catch (CloneNotSupportedException exception) { System.err.println("AbstractSpoon is not Cloneable"); } return object; } }
- 56. 4.2 Prototype 模式实现 - 具体原型 public class SaladSpoon extends AbstractSpoon { public SaladSpoon() { setSpoonName("Salad Spoon"); } } public class SoupSpoon extends AbstractSpoon { public SoupSpoon() { setSpoonName("Soup Spoon"); } }
- 57. 4.3 Prototype 模式实现 - 客户 public class Client { /** * @param args */ public static void main(String[] args) { AbstractSpoon spoon1 = new SoupSpoon(); AbstractSpoon spoon2 = (AbstractSpoon) spoon1.clone(); System.out.println(spoon2.getSpoonName()); AbstractSpoon spoon3 = new SaladSpoon(); AbstractSpoon spoon4 = (AbstractSpoon) spoon3.clone(); System.out.println(spoon4.getSpoonName()); } }
- 58. 5 ，带原型管理器的原型模式 户（ Client ）角色： 客户端类向原型管理器提出创建对象的请求。 象原型（ Prototype ）角色： 这是一个抽象角色，通常由一个接口或抽象类实现。 角色给出所有的具体原型类所需的接口。在 Java 中，抽象原型角色通常实现了 Cloneable 接口 体原型（ Concrete Prototype ）角色： 被复制的对象。此角色需要实现抽象的原型角色所要求的接口。 型管理器（ Prototype Manager ）角色： 创建具体原型类的对象，并记录每一个被创建的对象。
- 59. 5.1 带原型管理器的原型模式实现 – 原型管理器 import java.util.HashMap; public class SpoonManager { private HashMap hm = null; private static SpoonManager spoonManager = null; private SpoonManager(){ hm = new HashMap(); } public static synchronized SpoonManager getSpoonManager(){ if(spoonManager == null){ spoonManager = new SpoonManager(); } return spoonManager; } public void register(String name, Object prototype){ hm.put(name,prototype); } public void unRegister(String name){ hm.remove(name); } public Object getSpoon(String name){ Object o = null; if(hm.containsKey(name)){ o = hm.get(name); }else{ try{// 自动查找原型管理器里不存在的类，并动态生成它 o = Class.forName(name).newInstance(); this.register(name,o); }catch(Exception e){ System.out.println("class "+name+" don't define "+e.getMessage()); e.printStackTrace(); } } return ((AbstractSpoon)o).clone();
- 60. 5.2 带原型管理器的原型模式实现 – 客户 public class Client { /** * @param args */ public static void main(String[] args) { AbstractSpoon soupSpoon = new SoupSpoon(); AbstractSpoon saladSpoon = new SaladSpoon(); SpoonManager spoonManager = SpoonManager.getSpoonManager(); spoonManager.register("prototype.test.SoupSpoon", soupSpoon); spoonManager.register("prototype.test.SaladSpoon", saladSpoon); AbstractSpoon soupSpoon2 = (AbstractSpoon) spoonManager.getSpoon("prototype.test.SoupSpoon"); AbstractSpoon saladSpoon2 = (AbstractSpoon) spoonManager.getSpoon("prototype.test.SaladSpoon"); System.out.println(soupSpoon.hashCode()); System.out.println(soupSpoon2.hashCode()); System.out.println(saladSpoon.hashCode()); System.out.println(saladSpoon2.hashCode()); } }
- 61. 6 ， Prototype 模式的优点与缺点 ⑴Prototype 模式的优点： Prototype 模式允许动态增加或减少产品类。由于创建产品类 实例的方法是产批类内部具有的，因此增加新产品对整个结构 没有影响。 Prototype 模式提供了简化的创建结构。工厂方法模式常常需 要有一个与产品类等级结构相同的等级结构，而 Prototype 模 式就不需要这样。 Portotype 模式具有给一个应用软件动态加载新功能的能力。 由于 Prototype 的独立性较高，可以很容易动态加载新功能而 不影响老系统。 产品类不需要非得有任何事先确定的等级结构，因为 Prototype 模式适用于任何的等级结构。 ⑵Prototype 模式的缺点 Prototype 模式的最主要缺点就是每一个类必须配备一个克隆 方法。而且这个克隆方法需要对类的功能进行通盘考虑，这对 全新的类来说不是很难，但对已有的类进行改造时，不一定是 件容易的事。
- 62. 7, Prototype 原型模式总结 Prototype模式就是用来（通过）复制（创建）对象的。 什么时候应该使用prototype模式呢？ 1, 当你要创建的对象与现有运行时对象相似度很大时 2, 为了避免创建类的工厂类导致层次复杂度增加时 3, 当类的实例只有不多的几种状态时（此时需要引进原 型管理器）
- 63. Question Time
- 64. Thanks!