Is there a benefit from having a subclass method that only calls the overridden superclass method?

The only technical reason I can think of is what Michael proposed in the comments - making a restricted method become public.

However, I can think of a few human reasons.

For instance, this could be a convenient place to place a breakpoint for debugging invocations of disposeResultsTable of the child class. Or perhaps this was meant as a placeholder - "remember to implement this method for this class", or maybe someone wanted to explicitly point out to the reader of this code that this class uses the parent's implementation of disposeResultsTable. There are probably a bunch more options.

Have you tried looking up the history of this piece of code in the VCS? Maybe there's a helpful commit message from the original author.

The answer by Malt shows a common reason for overriding a method trivially by only calling the super implementation, namely to change the visibility from protected to public. Whether or not this might be the case in your example depends on the visibility of the respective method in the superclass...

However, there is another possible reason - although it might be a bit far-fetched and unusual - and this possible reason is reflection: The Class#getDeclaredMethods method only returns the methods that are... well, declared in this class.

For example, consider the following program:

import java.lang.reflect.Method;

public class TrivialOverride
{
    static class BaseClass
    {
        void method0() {}
        void method1() {}
    }
    static class ChildClass extends BaseClass
    {
        void method0() {}
    }

    public static void main(String[] args)
    {
        printDeclaredMethods(BaseClass.class);
        printDeclaredMethods(ChildClass.class);
    }

    private static void printDeclaredMethods(Class<?> c)
    {
        System.out.println("Declared methods in " + c.getSimpleName());
        for (Method m : c.getDeclaredMethods())
        {
            System.out.println(m.getName());
        }
        System.out.println();
    }
}

The output is

Declared methods in BaseClass
method0
method1

Declared methods in ChildClass
method0

So method0 only appears in the list of declared methods of the child class because it was overridden from the base class.