适配器与组合模式

适配器的优点

有一场景，就是不同的人实现不同的集合
A 使用数组的形式存放集合
B 使用List的方式存放集合

思考如何把两个集合数据很好的放到一块
解决方案：每个方法写一个适配器，调用方直接调用适配器

上面调用java.util中的迭代器进行操作。

上面那个Menu接口，可以解耦

上面的问题是，每当出现一个类，就会出现每当你添加一个菜单，就会修改构造方法和多调用一次printMenu，以下修改

看上去没什么问题了，但是当菜单包含子菜单的时候，问题又出现了。是无法被迭代的

组合模式

允许你将对象组合城树形结构来表现“整体/部分”层次结构。组合能让客户以一致的方式处理个别对象以及对象组合

实现

import java.util.Iterator;

/**
 * 菜单组件接口
 */
public abstract class MenuComponent {

    public void add (MenuComponent menuComponent){
        throw new UnsupportedOperationException();
    }

    public void remove (MenuComponent menuComponent){
        throw new UnsupportedOperationException();
    }

    public MenuComponent getChild (int i){
        throw new UnsupportedOperationException();
    }

    public String getName(){
        throw new UnsupportedOperationException();
    }

    public String getDescription(){
        throw new UnsupportedOperationException();
    }

    public double getPrice(){
        throw new UnsupportedOperationException();
    }

    public boolean isVegetarian(){
        throw new UnsupportedOperationException();
    }

    public void print(){
        throw new UnsupportedOperationException();
    }

    public abstract Iterator createIterator();

}

import java.util.ArrayList;
import java.util.Iterator;

public class Menu extends MenuComponent {

    ArrayList list = new ArrayList();
    String name;
    String description;

    public Menu(String name, String description) {
        this.name = name;
        this.description = description;
    }

    @Override
    public void add(MenuComponent menuComponent) {
        list.add(menuComponent);
    }

    @Override
    public void remove(MenuComponent menuComponent) {
        list.remove(menuComponent);
    }

    @Override
    public MenuComponent getChild(int i) {
        return (MenuComponent)list.get(i);
    }

    @Override
    public String getName() {
        return name;
    }

    @Override
    public String getDescription() {
        return description;
    }

    public void print(){
        System.out.println("\n" + getName());
        System.out.println("\n" + getDescription());
        System.out.println("----------------------");
        Iterator iterator = list.iterator();
        while(iterator.hasNext()){
            MenuComponent menuComponent = (MenuComponent)iterator.next();
            menuComponent.print();
        }

    }

    @Override
    public Iterator createIterator() {
        return new CompositeIterator(list.iterator());
    }

}

import java.util.Iterator;

public class MenuItem extends MenuComponent {

    String name;
    String description;
    boolean vegetarian;
    double price;

    public MenuItem(String name, String description, boolean vegetarian, double price) {
        this.name = name;
        this.description = description;
        this.vegetarian = vegetarian;
        this.price = price;
    }

    @Override
    public String getName() {
        return name;
    }

    @Override
    public String getDescription() {
        return description;
    }

    public void print(){
        System.out.println("name="+getName()+"desc="+getDescription());
    }

    @Override
    public boolean isVegetarian() {
        return vegetarian;
    }

    @Override
    public Iterator createIterator() {
        return new NullIterator();  // 这里也可以直接返回null
    }

    @Override
    public double getPrice() {
        return price;
    }

}

import java.util.Iterator;
import java.util.Stack;

public class CompositeIterator implements Iterator {

    Stack stack = new Stack();

    public CompositeIterator(Iterator iterator){
        stack.push(iterator);
    }

    @Override
    public Object next(){
        if(hasNext()){
            Iterator iterator = (Iterator)stack.peek();
            MenuComponent menuComponent = (MenuComponent)iterator.next();
            if(menuComponent instanceof Menu){
                stack.push(menuComponent.createIterator());
            }
            return menuComponent;
        }else{
            return null;
        }
    }

    @Override
    public boolean hasNext() {
        if(stack.empty()){
            return false;
        }else{
            Iterator iterator = (Iterator)stack.peek();
            if(!iterator.hasNext()){
                stack.pop();
                return hasNext();
            }else{
                return true;
            }
        }
    }

    @Override
    public void remove() {
        throw new UnsupportedOperationException();
    }
}

import java.util.Iterator;

public class Waitress {

    MenuComponent allMenus;

    public Waitress(MenuComponent allMenus) {
        this.allMenus = allMenus;
    }

    public void printMenu(){
        allMenus.print();
    }

    public void printVegetarianMenu(){
        Iterator iterator = allMenus.createIterator();
        while (iterator.hasNext()){
            MenuComponent menuComponent = (MenuComponent)iterator.next();
            try {
                if(menuComponent.isVegetarian()){
                    menuComponent.print();
                }
            }catch (UnsupportedOperationException e) {

            }
        }
    }
}

import java.util.Iterator;

public class NullIterator implements Iterator {
    @Override
    public boolean hasNext() {
        return false;
    }

    @Override
    public Object next() {
        return null;
    }

    @Override
    public void remove() {
        throw new UnsupportedOperationException();
    }
}

测试，主要实现了树结构，目前结构只支持一层，压栈的逻辑有些问题

public class test {

    public static void main(String[] args) {
        MenuComponent menu1 = new Menu("1", "1");
        MenuComponent menu2 = new Menu("1","2");
        MenuComponent menu3 = new Menu("1","3");
        MenuComponent menu4 = new Menu("1","4");

        MenuComponent head = new Menu("0","0");

        head.add(menu1);
        head.add(menu2);
        head.add(menu3);
//        head.add(menu4);


        // 添加子菜单
        MenuItem son = new MenuItem("1", "子", false, 0.12);
        MenuItem son2 = new MenuItem("2", "子", true, 0.12);
        menu1.add(son);

        Waitress waitress = new Waitress(head);
//        waitress.printMenu();

        waitress.printVegetarianMenu();

    }
}