Обход дерева с вызовом действий в узлах

С использованием паттерна Visitor:

class Node {
    protected final Node[] childs;
    public Node() {
        this(new Node[] {});
    }
    public Node(final Node[] childs) {
        this.childs = childs;
    }
    public Node[] childs() {
        return this.childs;
    }
    public void accept(final Action visitor) {
        for (final Node child : childs()) {
            child.accept(visitor);
        }
        visitor.act(this);
    }
}
interface Action {
    default void act(final Node node) {
        if (node instanceof NodeA) {
            this.act((NodeA) node);
        } else if (node instanceof NodeB) {
            this.act((NodeB) node);
        }
        else if (node instanceof NodeC) {
            this.act((NodeC) node);
        } else if (node instanceof NodeD) {
            this.act((NodeD) node);
        }
    }
    default void act(final NodeB node) {}
    default void act(final NodeA node) {}
    default void act(final NodeC node) {}
    default void act(final NodeD node) {}
}
class NodeA extends Node {
    public NodeA(final Node[] elements) {
        super(elements);
    }
}
class NodeB extends Node {}
class NodeC extends Node {}
class NodeD extends Node {}
class ActionA implements Action {
    @Override
    public void act(final NodeB node) {
        System.out.println("Action A / Node B");
    }
    @Override
    public void act(final NodeA node) {
        System.out.println("Action A / Node A");
    }
}
class ActionB implements Action {
    @Override
    public void act(final NodeC node) {
        System.out.println("Action B / Node C");
    }
    @Override
    public void act(final NodeD node) {
        System.out.println("Action B / Node D");
    }
}
public class ApplicationDemo {
    public static void main(final String[] args) {
        final Node node = new NodeA(new Node[]{
                new NodeB(), new NodeD(),
                new NodeB(), new NodeC()
        });
        node.accept(new ActionB());
        node.accept(new ActionA());
    }
}

Результат:

Action B / Node D
Action B / Node C
Action A / Node B
Action A / Node B
Action A / Node A