大话设计模式-----(七)备忘录模式、组合模式

太过爱你忘了你带给我的痛 2022-06-18 02:08 142阅读 0赞

## 备忘录模式 ##

在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。这样就以后额可将该对象恢复到原先保存的状态。

书上的例子就是游戏进度保存，打不过boss后进行回档，那么数据要恢复过来。简单的写的话，会将存储的数据和如何存储保存恢复等暴露给了客户端。那么在游戏角色类中添加一个游戏进度存储和恢复的类。恢复传入一个存储类。传入的这个存储类和游戏角色差不多。主要有要保存的属性。恢复的话方法传入这个存储类。用传入的这个存储类的属性给游戏角色的属性赋值。因为是之前保存的。保存的方法是返回一个存储类。  
那么就要让存储类的构造函数初始传入要保存的属性。在游戏角色类中返回并初始化。

最后创建一个游戏角色状态管理者。里面的属性只有存储类。设置set get方法。来设置 存储类。

具体代码

游戏角色类

//游戏角色类
    
    class GameRole{
        private int vit;
        private int atk;
        private int def;
        public int getVit() {
            return vit;
        }
        public void setVit(int vit) {
            this.vit = vit;
        }
        public int getAtk() {
            return atk;
        }
        public void setAtk(int atk) {
            this.atk = atk;
        }
        public int getDef() {
            return def;
        }
        public void setDef(int def) {
            this.def = def;
        }
    
        //状态显示
        public void StateDisplay(){
            System.out.println("体力"+vit);
            System.out.println("攻击力"+atk);
            System.out.println("防御力"+def);
    
        }
        //设置初始状态
        public void GetInitSate(){
            vit = 100;
            atk = 100;
            def = 100;
    
        }
    
        //战斗后所有清为0
        public void Fight(){
            vit = 0;
            atk = 0;
            def = 0;
    
        }
    
    //保存角色状态
    
        public RoleStateMemento SaveState(){
    
            return new RoleStateMemento(vit,atk,def);
        }
    //恢复角色状态
        public void RecoverState(RoleStateMemento memento){
            vit = memento.getVit();
            atk = memento.getAtk();
            def = memento.getDef();
    
        }
    
    }

存储类

class RoleStateMemento{
        private int vit;
        private int atk;
        private int def;
        //构造函数，直接传入属性值
        public RoleStateMemento(int vit,int atk,int def){
            this.vit = vit;
            this.atk = atk;
            this.def = def;
        }
    
        public int getVit() {
            return vit;
        }
        public void setVit(int vit) {
            this.vit = vit;
        }
        public int getAtk() {
            return atk;
        }
        public void setAtk(int atk) {
            this.atk = atk;
        }
        public int getDef() {
            return def;
        }
        public void setDef(int def) {
            this.def = def;
        }
    
    }

游戏角色管理者

//创建一个角色管理类，
    
    class RoleStateCaretaker{
        private RoleStateMemento memento;
    
        public RoleStateMemento getMemento() {
            return memento;
        }
    
        public void setMemento(RoleStateMemento memento) {
            this.memento = memento;
        }
    
    
    }

客户端

public static void main(String[] args) {
            GameRole gameRole = new GameRole();
            gameRole.GetInitSate();
            System.out.println("初始状态");
            gameRole.StateDisplay();
            //创建管理类
            RoleStateCaretaker roleStateCaretaker= new  RoleStateCaretaker();
            roleStateCaretaker.setMemento(gameRole.SaveState());
    
            //游戏战斗
            gameRole.Fight();
            System.out.println("游戏战斗后状态");
            gameRole.StateDisplay();
    
            //恢复状态
            gameRole.RecoverState(roleStateCaretaker.getMemento());
            System.out.println("恢复状态");
            gameRole.StateDisplay();
        }

![这里写图片描述][SouthEast]

主要就是在游戏角色中添加了保存和恢复，另外创建了一个存储类。最后创建一个管理者。全都不在客户端进行。隐藏细节

## 组合模式 ##

将对象组合成树形结构以表示 部分-整体 的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性。

定义一个抽象出来的节点。还有name属性和增加删除显示方法。增加的话就传入这个节点。删除同样。写两个继承一个是叶子一个是有节点。叶子只是实现增加删除方法就行了。然后客户端就创建，添加就可以了。  
抽象出来一个，包含name属性和增加删除节点显示方法  
节点增加即可。不同的组合着来。

abstract class Component{
        String name;
        public Component(String name){
            this.name = name;
        }
    
        //增加节点
        public abstract void Add(Component c);
        //删除节点
        public abstract void Remove(Component c);
        //显示节点
        public abstract void Display(int depth);
    
    }

叶子

//创建一个叶子
    
    class Lead extends Component{ 
    
        public Lead(String name) {
            super(name);
    
        }
    //但是因为没有节点了。后面的增加和删除方法就不用写了。但是还是要实现
        @Override
        public void Add(Component c) {
            // TODO Auto-generated method stub
    
        }
    
        @Override
        public void Remove(Component c) {
            // TODO Auto-generated method stub
    
        }
    
        @Override
        public void Display(int depth) {
            // TODO Auto-generated method stub
            System.out.println(depth+" "+name);
        }
    
    }

有节点的

//定义一个有节点的
    
    class Composite extends Component{ 
    
        //
        private List<Component> childrenComponents = new ArrayList<Component>();
    
        public Composite(String name) {
            super(name);
            // TODO Auto-generated constructor stub
        }
    
        @Override
        public void Add(Component c) {
            // TODO Auto-generated method stub
            childrenComponents.add(c);
        }
    
        @Override
        public void Remove(Component c) {
            // TODO Auto-generated method stub
            childrenComponents.remove(c);
        }
    
        @Override
        public void Display(int depth) {
            // TODO Auto-generated method stub
            System.out.println(depth+" "+name);
            for (Component c :childrenComponents){
                c.Display(depth+2);
            }
        }
    
    }

客户端

public static void main(String[] args){
        Composite root = new Composite("root");
        root.Add(new Lead("A"));
        root.Add(new Lead("B"));
    
        Composite composite = new Composite("Composite x");
        composite.Add(new Lead("Leaf XA"));
        composite.Add(new Lead("Leaf XB"));
    
        root.Add(composite);
    
        Composite composite2 = new Composite("Composie XY");
        composite2.Add(new Lead("XYA"));
        composite2.Add(new Lead("XYB"));
    
        composite.Add(composite2);
    
        root.Add(new Lead("Lead C"));
        Lead leaf = new Lead("Leaf D");
    
        root.Add(leaf);
        root.Remove(leaf);
    
        root.Display(1);
    
    
        }
    
    }

![这里写图片描述][SouthEast 1]

可以是比如说每个公司的很多分公司 分公司有很多跟主公司一样的分部门就可以使用。

组合模式让客户可以一致的使用组合结构和单个对象  
基本对象可以组合成更复杂的组合对象，而这个组合对象又可以被组合，这样不断地递归下去。

[SouthEast]: /images/20220618/0ea765d2d194445b895fddac567277c6.png
[SouthEast 1]: /images/20220618/9f84164b0b4d49fa83af38e6e0023648.png