Visitor pattern with reflection

SyntaxTreeNodeVisitor.java

package syntax;

import syntax.tree.SyntaxTreeNode;
import syntax.tree.arithmetic.*;
import syntax.tree.comparison.EqualityNode;
import syntax.tree.comparison.IsVoidNode;
import syntax.tree.comparison.LessOrEqualThanNode;
import syntax.tree.comparison.LessThanNode;
import syntax.tree.conditional.CaseNode;
import syntax.tree.conditional.ConditionNode;
import syntax.tree.constant.BoolConst;
import syntax.tree.constant.IntConst;
import syntax.tree.constant.StringConst;
import syntax.tree.dispatch.DispatchNode;
import syntax.tree.dispatch.StaticDispatchNode;
import syntax.tree.logical.NegateNode;
import syntax.tree.looping.LoopNode;
import syntax.tree.object.AssignNode;
import syntax.tree.object.NewNode;
import syntax.tree.object.ObjectNode;
import syntax.tree.structure.BlockNode;
import syntax.tree.structure.LetNode;
import syntax.tree.toplevel.AttributeNode;
import syntax.tree.toplevel.ClassNode;
import syntax.tree.toplevel.MethodNode;
import syntax.tree.toplevel.ProgramNode;

public abstract class SyntaxTreeNodeVisitor<E> {
  // Arithmetic.
  public abstract E visit(AdditionNode node);

  public abstract E visit(ComplementNode node);

  public abstract E visit(DivisionNode node);

  public abstract E visit(MultiplicationNode node);

  public abstract E visit(SubtractionNode node);

  // Comparison.
  public abstract E visit(EqualityNode node);

  public abstract E visit(IsVoidNode node);

  public abstract E visit(LessOrEqualThanNode node);

  public abstract E visit(LessThanNode node);

  // Conditional.
  public abstract E visit(CaseNode node);

  public abstract E visit(ConditionNode node);

  // Constant.
  public abstract E visit(BoolConst node);

  public abstract E visit(IntConst node);

  public abstract E visit(StringConst node);

  // Dispatch.
  public abstract E visit(DispatchNode node);

  public abstract E visit(StaticDispatchNode node);

  // Logical.
  public abstract E visit(NegateNode node);

  // Structure.
  public abstract E visit(BlockNode node);

  public abstract E visit(LetNode node);

  // Object.
  public abstract E visit(AssignNode node);

  public abstract E visit(NewNode node);

  public abstract E visit(ObjectNode node);

  // Looping.
  public abstract E visit(LoopNode node);

  // Top level.
  public abstract E visit(ProgramNode node);

  public abstract E visit(ClassNode node);

  public abstract E visit(AttributeNode node);

  public abstract E visit(MethodNode node);

  public E visit(SyntaxTreeNode node) {
    E result = null;
    try {
      result = (E) getClass().getDeclaredMethod("visit", node.getClass()).invoke(this, node);
    } catch (Exception e) {
      e.printStackTrace();
    }
    return result;
  }
}

Btw. You know that these things are public, right?