🚀 go-pugleaf

Hi,

Just trying out Java and had a few questions about patterns.

1. When designing with the Visitor pattern, is it better to start with an
abstract class at the top of the hierarchy or to declare an interface and
implement where needed.

2. Would visitors typically return a value from their visitObj(Object obj)
method?

3. The app I'm writing has to crawl hierarchal object trees (Borland's
Caliber TreeNodes).  So looping over the nodes and calling Visitor seems
appropriate.

But we don't always want to visit every node; we may want to skip some.  It
seemed a Strategy pattern that had a method like isObjInSet(Object obj)
might be appropriate.

Combining these things, I thought a Crawler class that took a set of objects
(or the root of an object tree), a strategy object and a visitor object
could be useful: I wouldn't have to worry about the looping code ever
again...just instantiate my crawler with the three elements and it would go
about its business.

Make sense?

4. Strictly speaking if a class implements visitorObjectParent(ObjectParent
objP), should it touch objP's children?  In other words, is the following
appropriate?

public void visitObjectParent(ObjectParent objP){
    ObjectChildren[] objC = objP.getChildren();

    for (int x = 0; x <objC.length; x++){
        doSomethingToChild(objC);
    }
}

5. If #4 is appropriate but I want to vary what happens in
doSomethingToChild(), is it ok to pass in a Visitor or Command object (e.g.,
ObjectParentVisitor v = new ObjectParentVisitor(ChildVisitor) to specify the
action to take against the child?  And if action should not be taken against
EVERY child, could another Strategy pattern be passed in?

Thanks.

(And if these are crazy questions, I  hope they're at least amusing.)