java中的模式 -凯发k8网页登录

开发出高质量的系统

常用链接

统计

积分与排名

好友之家

最新评论

java中的模式 --- 双重接口的实现,备忘录模式

一、定义：备忘录(memento)模式又叫快照(snapshot)模式或者token模式，主要功能：
备忘录模式是用一个对象来存储另外一个对象的内部状态的快照，实现备忘录模式的关键点是在不破坏封装的
情况下，将一个对象的状态捕捉住，并外部化，存储起来，从而可以在合适的时候，把这个对象还原。
说明：备忘录模式适模式中比较好理解的一个，这里就不举例子，但是备忘录模式是模式中实现比较难，或者说
实现比较巧的，这里主要说说。
二、备忘录模式的实现
1,备忘录模式中的角色
发起人：创建含有内部状态的备忘录对象，并使用备忘录对象存储状态
负责人：负责人保存备忘录对象，但不检查备忘录对象的内容
备忘录：备忘录对象将发起人对象的内部状态存起来，并保正其内容不被发起人对象之外的对象像读取
注意：在备忘录的角色中，定义了他必须对不同的人提供不同的接口，对发起人提供宽接口，对其它任何人提供窄
接口。也许你说我都提供宽接口得了。对这也是备忘录的一种实现，叫做白箱备忘录，不过这种方法的封装没有设计
好，安全性不够好。
2,白箱备忘录的实现：
 1public class originator{
 2    private string state;
 3    public memento creatememento(){
 4        return new memento(state);
 5    }
 6    public void restorememento(memento memento){
 7        this.state = memento.getstate();
 8    }
 9    public string getstate(){
10        return this.state;
11    }
12    public void setstate(string state){
13        this.state=state;
14        system.out.println("current state = "  this.state);
15    }
16}
17public class memento{
18    private string state;
19    public memento(string state){
20        this.state = state;
21    }
22    public string getstate(){
23        return this.state;
24    }
25    public void setstate(){
26        this.state = state;
27    }
28}
29public class caretaker{
30    private memento memento;
31    public memento retrievememento(){
32        return this.memento;
33    }
34    public void savememento(memento memento){
35        this.memento = memento;
36    }
37}
38public class client{
39    private static originator o = new originator();
40    private static caretaker c = new caretaker();
41    public static void main(sting[] args){
42        o.setstate("on");
43        c.savememento(o.creatememento());
44        o.setstate("off");
45        o.restorememento(c.retrievememento());
46    }
47}
白箱的优点：实现简单
白箱的缺点：上边说了，破坏了封装，安全性有些问题。
说明：这里白箱的实现只保存了一个状态，其实是可以保存多个状态的。
3，双接口的实现，宽窄接口（黑箱)
如何实现宽窄接口呢，内部类也许是个好方法。我们把备忘录类设计"成发起人"的内部类，但这样还有的问题是同一
package中的其它类也能访问到，为了解决这个问题，我们可以把"备忘录"的方法设计成私有的方法，这样就
可以保正封装，又保正发起人能访问到。实现如下：
定义窄接口.
 1public interface narrowmemento{
 2    public void narrowmethod();
 3}
 4class originator {
 5    private string state;
 6    private narrowmemento memento;
 7    public originator(){
 8    }
 9    public narrowmemento creatememento(){
10        memento = new memento(this.state);
11        return memento;
12    }
13    public void restorememento(narrowmemento memento){
14        memento amemento = (memento)memento;
15        this.setstate(amemento.getstate());
16    }
17    public string getstate(){
18        return this.state;
19    }
20    public void setstate(string state){
21        this.state = state;
22    }
23    //内部类
24    protected class memento implements narrowmemento{
25        private string savedstate;
26        private memento(string somestate){
27            savestate = somestate;
28        }
29        private void setstate(string somestate){
30            savestate = somestate;
31        }
32        private string getstate(){
33            return savestate;
34        }
35        public void narrowmethod(){
36            system.out.println("this is narrow method");
37        }
38        
39    }
40    public narrowmemento getnarrowmemento(){
41        return memento;
42    }
43}
44public class caretaker{
45    private narrowmemento memento;
46    public narrowmemento retrievememento(){
47        return this.memento;
48    }
49    public void savememento(narrowmemento memento){
50        this.memento = memento;
51    }
52}
53public class client{
54    private static originator o = new originator();
55    private static caretaker c = new caretaker();
56    public static void main(string[] args){
57        //use wide interface
58        o.setstate("on");
59        c.savememento(o.creatememento());
60        o.setstate("off");
61        o.restorememento(c.retrievememento());
62        //use narrow interface
63        narrowmemento memento = o.getnarrowmemento();
64        memento.narrowmethod();
65        
66    }
67}
ok，实现了对大多数人实现比较窄的接口，对originator实现了宽接口.
三,最后的一些说明：
1，前边两个例子都是记录了单个状态(单check点)，要实现多个状态点很容易，只须要把记录state的字符串换
成一个list，然後添加，取得。如果须要随机须得状态点，也可以用map来存放.这样多个check点就实现了。
2，一般情况下可以扩展负责人的功能，让负责人的功能更强大，从而让客户端的操做更少些。解放客户端。
3，自述历史模式，这个就是把发起人，负责人写在一个类中，平时的应用中这种方法比较常见。

posted on 2006-12-03 10:40 dreamstone 阅读(2423) 评论(1)  编辑  收藏 所属分类: 设计模式

# re: java中的模式 --- 双重接口的实现,备忘录模式 2007-08-04 21:36

"开发出高质量的系统",我们需要你这样的人,这样的思想,这样的文章,谢谢分享!  回复     


只有注册用户后才能发表评论。
网站导航:
              
 
网站地图