Every node in binary tree = sum of subtree

This part of your code could probably be simplified

if (node.getLeft() != null && node.getRight() != null)
{
    if ((Integer) node.getData() != sum)
    {
        return false;
    }
}
else
    return true;

First off, don't do an else statement without curly braces when the corresponding if statement has curly braces, it doesn't follow expected coding practices.

Then you should return early

if (node.getLeft() == null || node.getRight() == null) {
    return true;
} else if ((Integer) node.getData() != sum) {
    return false;
}

As your code is written in the original post it will never hit this statement

return isValid(node.getLeft()) && isValid(node.getRight());

and will always return true, if (node.getLeft() == null || node.getRight() == null)

You don't need to compute the sum every time: this is terrible for performance, as you are re-evaluating the same nodes again and again (think of a leaf, it gets evaluated for every node in the chain!).

A tree that has the property you described follows the following rule:

for each node:

• if I'm a leaf, I can hold any value
• otherwise, my value must be f(right) + f(left)

where f(node) is defined as:

• If n is a leaf, f(n) = value(n)
• if n is not a leaf, f(n) = 2*value(n)

This is because leaves only carry their own weight, while nodes bring both their value and the value of their subtrees (hence 2x)

There may be some edge cases that I missed, but the gist of the solution would become something like:

boolean isValidNode(node) {
  if (!isLeaf(node)) return node.value == f(node.left) + f(node.right);
  else return true;
}

int f(node) {
   if (node==null) return 0;
   else if (isLeaf(node)) return node.value;
   else return 2*node.value;
}

boolean isValidNodeRec(node) {
  if (node==null) return true;
  else return isValidNode(node) && isValidNodeRec(node.left) && isValidNodeRec(node.right);
}

boolean isValidTree(root) {
  isValidNodeRec(root);  
}

Your logic is difficult to read. The jump from the nested if-statement to the final return-statement, if the node value is equal to the calculated sum, is not obvious. Proceed step by step in a logical way, by successively handling and eliminating cases.

Let's add this method to the BinaryNode<E> class

public boolean isLeafNode()
{
    return left == null && right == null;
}

I suggest to change the isValid method like this:

public boolean isValid(BinaryNode<E> node)
{
    if (node == null || node.isLeafNode())
        return true;

    if (!isValid(node.getLeft()) || !isValid(node.getRight()))
        return false;

    int sum = sumOfSub(node.getLeft()) + sumOfSub(node.getRight());
    return (Integer)node.getData() == sum;
}

Note that the rule should be:

Every node's value must be the sum of the values of the nodes of its subtree, unless the node is a leaf node (in which case its subtree is an empty tree). A leaf node is always valid.

Without the last statement a leaf node's value would always have to be 0.

No if-statement is required for the test of the sum; just return the result of the comparison. This version can be read in a very linear way, without confusing jumps and else cases.