14命令与迭代器模式代码实现

合集 - 设计模式(17)

1.00设计模式基础2023-04-242.01六种关系2023-04-243.15观察者与状态模式2023-04-244.16观察者与状态模式代码实现2023-04-245.17策略与模板方法模式2023-04-246.18策略与模板方法模式的代码实现2023-04-24

7.14命令与迭代器模式代码实现2023-04-24

8.13命令与迭代器模式2023-04-249.12桥接和代理模式代码实现2023-04-2410.11桥接和代理模式2023-04-2411.10装饰与外观模式代码实现2023-04-2412.09装饰与外观模式2023-04-2413.08适配器和组合模式代码实现2023-04-2414.07适配器与组合模式2023-04-2415.06原型和单例模式代码实现2023-04-2416.05原型与单例模式2023-04-2417.04工厂方法和抽象工厂模式代码实现2023-04-24

收起

命令模式代码实现

• 为了用户使用方便，某系统提供了一系列功能键。用户可以自定义功能键的功能，例如功能键FunctionButton可以用于退出系统（由SystemExitClass类来实现），也可以用于显示帮助文档（由DisplayHelpClass类来实现）。用户可以通过修改配置文件来改变功能键的用途，现使用命令模式来设计该系统，使得功能键类与功能类之间解耦，可为同一个功能键设置不同的功能。

1. 类图：

2. 源代码：

• Command

package com.fish.pattern.command.lab1;  
  
public interface Command {  
    public void execute();  
}

• ExitCommand

package com.fish.pattern.command.lab1;  
  
public class ExitCommand implements Command{  
    private SystemExitClass sec;  
  
    public ExitCommand(){  
        sec = new SystemExitClass();  
    }  
  
  
    @Override  
    public void execute() {  
        sec.exit();  
    }  
}

• HelpCommand

package com.fish.pattern.command.lab1;  
  
public class HelpCommand implements Command {  
    private DisplayHelpClass dhc;  
  
    public HelpCommand() {  
        dhc = new DisplayHelpClass();  
    }  
  
  
    @Override  
    public void execute() {  
        dhc.display();  
    }  
}

• FunctionButton

package com.fish.pattern.command.lab1;  
  
public class FunctionButton {  
    private Command command;  
  
    public void setCommand(Command command) {  
        this.command = command;  
    }  
  
    public void click(){  
        System.out.println("单击了按钮");  
        command.execute();  
    }  
}

• DisplayHelpClass

package com.fish.pattern.command.lab1;  
  
public class DisplayHelpClass {  
    public void display(){  
        System.out.println("显示帮助文档");  
    }  
}

• SystemExitClass

package com.fish.pattern.command.lab1;  
  
public class SystemExitClass {  
    public void exit(){  
        System.out.println("退出了系统");  
    }  
}

• Client

package com.fish.pattern.command.lab1;  
  
public class Client {  
    public static void main(String[] args) {  
        FunctionButton fb = new FunctionButton();  
        Command exitCommand = new ExitCommand();  
        fb.setCommand(exitCommand);  
        fb.click();  
  
        FunctionButton fb1 = new FunctionButton();  
        Command helepCommand = new HelpCommand();  
        fb.setCommand(helepCommand);  
        fb.click();  
    }  
}

3. 运行结果：

• 设计一个简易计算器。该计算器可以实现简单的数学运算（加运算或减运算），还可以对运算（加运算或减运算)实施撤销操作。请使用命令模式设计程序实现上述功能并绘制其类图。

1. 类图：

2. 源代码：

• AbstractCommand

package com.fish.pattern.command.lab2;  
  
public abstract class AbstractCommand {  
  
    public abstract int execute(int value);  
    public abstract int undo();  
  
}

• AddCommand

package com.fish.pattern.command.lab2;  
  
public class AddCommand extends AbstractCommand{  
  
    private Adder adder= new Adder();  
    private int value;  
  
    @Override  
    public int execute(int value) {  
        this.value = value;  
        return adder.add(value);  
    }  
  
    @Override  
    public int undo() {  
        return adder.add(-value);  
    }  
}

• Adder

package com.fish.pattern.command.lab2;  
  
public class Adder {  
    private int num = 0;  
    public int add(int value){  
        return  num+=value;  
    }  
}

• CalculatorForm

package com.fish.pattern.command.lab2;  
  
public class CalculatorForm {  
    public AbstractCommand command;  
  
    public void setCommand(AbstractCommand command) {  
        this.command = command;  
    }  
  
    public void compute(int value){  
        int i =command.execute(value);  
        System.out.println("执行运算，运算结果为："+i);  
    }  
  
    public void undo(){  
        int i = command.undo();  
        System.out.println("执行撤销，运算结果为："+i);  
    }  
}

• Client

package com.fish.pattern.command.lab2;  
  
public class Client {  
    public static void main(String[] args) {  
        CalculatorForm form = new CalculatorForm();  
        AbstractCommand command = new AddCommand();  
        form.setCommand(command);  
        form.compute(10);  
        form.compute(5);  
        form.compute(15);  
        form.undo();  
    }  
}

3. 运行结果：

迭代模式代码实现

• 使用迭代器模式遍历销售管理系统数据。

1. 类图：

2. 源代码：

• AbstractIterator

package com.fish.pattern.iterator;  
  
public interface AbstractIterator {  
  
    void next();  
    boolean isLast();  
    boolean isFirst();  
    void previous();  
    Object getNextItem();  
    Object getPreviousItem();  
}

• AbstractObjectList

package com.fish.pattern.iterator;  
  
import java.util.ArrayList;  
import java.util.List;  
  
public abstract class AbstractObjectList {  
  
    protected List<Object> objects = new ArrayList<>();  
  
    public AbstractObjectList(List<Object> objects) {  
        this.objects = objects;  
    }  
  
    public void addObject(Object obj) {  
        objects.add(obj);  
    }  
  
    public void removeObject(Object obj) {  
        objects.remove(obj);  
    }  
  
    public List getObjects() {  
        return objects;  
    }  
  
    public abstract AbstractIterator createIterator();  
  
}

• Client

package com.fish.pattern.iterator;  
  
import java.util.ArrayList;  
  
public class Client {  
    public static void main(String[] args) {  
        ArrayList<Object> products = new ArrayList<>();  
        products.add("糯米鸡");  
        products.add("甜玉米");  
  
        AbstractObjectList list;  
        AbstractIterator iterator;  
  
        list = new ProductList(products);  
        iterator = list.createIterator();  
  
        System.out.println("正向遍历：");  
        while (!iterator.isLast()){  
            System.out.print(iterator.getNextItem()+",");  
            iterator.next();  
        }  
        System.out.println();  
        System.out.println("--------------------------");  
        System.out.println("反向遍历：");  
        while (!iterator.isFirst()){  
            System.out.print(iterator.getPreviousItem()+",");  
            iterator.previous();  
        }  
  
    }  
}

• ProductIterator

package com.fish.pattern.iterator;  
  
import java.util.List;  
  
public class ProductIterator implements AbstractIterator{  
  
    private ProductList productList;  
    private List products;  
    private int cursor1;  
    private int cursor2;  
  
    public ProductIterator(ProductList list) {  
        this.productList = list;  
        this.products = list.getObjects(); //获取集合对象  
        cursor1 = 0; //设置正向遍历游标的初始值  
        cursor2 = products.size() -1; //设置逆向遍历游标的初始值  
    }  
  
    @Override  
    public void next() {  
        if(cursor1 < products.size()) {  
            cursor1++;  
        }  
    }  
  
    @Override  
    public boolean isFirst() {  
        return (cursor2 == -1);  
    }  
  
    @Override  
    public boolean isLast() {  
        return (cursor1 == products.size());  
    }  
  
    @Override  
    public void previous() {  
        if (cursor2 > -1) {  
            cursor2--;  
        }  
    }  
  
    @Override  
    public Object getNextItem() {  
        return products.get(cursor1);  
    }  
  
    @Override  
    public Object getPreviousItem() {  
        return products.get(cursor2);  
    }  
  
}

• ProductList

package com.fish.pattern.iterator;  
  
import java.util.List;  
  
public class ProductList extends AbstractObjectList{  
  
    public ProductList(List products) {  
        super(products);  
    }  
  
    @Override  
    public AbstractIterator createIterator() {  
        return new ProductIterator(this);  
    }  
}

3. 运行结果：