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

备忘录模式

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

书上的例子就是游戏进度保存，打不过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();
    }

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

组合模式

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

定义一个抽象出来的节点。还有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);


    }

}

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

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