谁说visitor不可以添加新元素?

这个visitor就可以随便添加,利用反射就可以做到了.

public abstract class Visitor {

    final public void visit(Object object) {
        Method method = getVisitMethod(object);
        try {
            method.invoke(this, new Object[] { object });
        } catch (Exception e) {
            String message = "invokeing method failed:visit("
                    + object.getClass().getName() + ")";
            throw new RuntimeException(message, e);
        }
    }

    private Map visitMethods = new HashMap();

    private Method getVisitMethod(Object object) {
        //return (Method) visitMethods.get(object.getClass());
        Iterator it = visitMethods.keySet().iterator();
        for (; it.hasNext();) {
            Class clazz = (Class) it.next();
            if (clazz.isAssignableFrom(object.getClass())) {
                return (Method) visitMethods.get(clazz);
            }
        }
        throw new RuntimeException("method: visit(" + object.getClass().getName()
                + ") undefined in the class");
    }

    private Method visitMethod;

    private void initVisitMethod() {
        Method[] methods = getClass().getDeclaredMethods();
        for (int i = 0; i < methods.length; i++) {
            if (methods[i].getName().equals("visit")) {
                Class[] paramTypes = methods[i].getParameterTypes();
                if (paramTypes.length == 1) {
                    visitMethods.put(paramTypes[0], methods[i]);
                }
            }
        }
    }

    {
        initVisitMethod();
    }
}

下面是两个具体的Visitor

public class PrintVisitor extends Visitor{

    public void visit(Float f){
        System.out.println("float:"+f);
    }
    public void visit(Date date){
        System.out.println("date:"+date);
    }
    public void visit(String str){
        System.out.println("string:"+str);
    }
}

public class PrintVisitor2 extends Visitor{

    public void visit(String str){
        System.out.println("string2:"+str);
    }
    public void visit(List list){
        System.out.println("list2:"+list);
    }
}

    public void testVisit(){
        ArrayList list = new ArrayList();
        list.add("a");
        list.add("b");
        Visitor v = new PrintVisitor();
        v.visit("hello");
        v.visit(new Date());
        Visitor v1 = new PrintVisitor2();
        v1.visit("hello");
        v1.visit(list);
    }

发现项目中老用visitor，不爽
不过现在很爽了，呵呵

刚写好，测试量不够，望各位多指点指点．．

如果要设计组件之类的东东，应该经常用到visitor才对啊．．．

反射的威力不小呀？

假设有个类层次结构
A, B extends A, C extends A
你也实现了PrintVisitor,可以打印A,B,C
public class PrintVisitor extends Visitor{  
 
    public void visit(A a){  
    }
    public void visit(B b){
    }
    public void visit(C c){
    }
}  

问题是，我现在要增加一个类 D extends A
那么你的PrintVisitor还是要改变啊

当然也可以继承一个新的NewPrintVisitor
public class NewPrintVisitor extends PrintVisitor{  
 
    public void visit(D d){
    }
}  
但是原来的的visitor也可以这样子实现。
我觉得主要的问题是，如果我有1000个visitor，那么就多了1000个新的visitor，如果我又多了更多的元素呢？

对于以前的visitor,如果需要新的功能(元素),那你的接口就要变,那么你所有的Visitor都得重写,如果第三方还用到了visitor,那就根本无法改变.也就是完全不兼容.

但现在,以前的Visitor可以不变,也就是说以前的功能还是存在(只是不能处理新的元素).
新加进来的元素可以用新的Visitor来处理,就像是一个完全兼容的升级版本.

而这也是一般实际情况 ^_^