Is using static private methods really faster/better than instance private methods?

Question

What I'm asking is whether there is a difference between doing this:

public Something importantBlMethod(SomethingElse arg) {
    if (convenienceCheckMethod(arg)) {
        // do important BL stuff
    }
}

private boolean convenienceCheckMethod(SomethingElse arg) {
    // validate something
}

And this:

public Something importantBlMethod(SomethingElse arg) {
    if (convenienceCheckMethod(arg)) {
        // do important BL stuff
    }
}

private static boolean convenienceCheckMethod(SomethingElse arg) {
    // validate something
}

I actually use option 1 as it seems more natural to me.

So is there a style/convention/performance difference between the first and the second way ?

Thanks,

---

As suggested in the comments I tested it, in my benchmarks the dynamic method is faster.

This is the test code:

public class Tests {

    private final static int ITERATIONS = 100000;

    public static void main(String[] args) {
        final long start = new Date().getTime();

        final Service service = new Service();
        for (int i = 0; i < ITERATIONS; i++) {

            service.doImportantBlStuff(new SomeDto());
        }

        final long end = new Date().getTime();

        System.out.println("diff: " + (end - start) + " millis");
    }
}

This is the service code:

public class Service {

    public void doImportantBlStuff(SomeDto dto) {

        if (checkStuffStatic(dto)) {

        }

        // if (checkStuff(dto)) {

        // }
    }

    private boolean checkStuff(SomeDto dto) {
        System.out.println("dynamic");
        return true;
    }

    private static boolean checkStuffStatic(SomeDto dto) {
        System.out.println("static");
        return true;
    }
}

For 100000 iterations the dynamic method passes for 577ms, the static 615ms.

This however is inconclusive for me since I don't know what and when the compiler decides to optimize.

This is what I'm trying to find out.

Answer 1

Performance wise: The difference, if any, is negligible.

The rule of thumb is to declare your method static if it doesn't interact with any members of its class.

Answer 2

If the result of the function does not depend on anything but the arguments, it should be static. If it depends on an instance, make it an instance member.

It's not about performance; it's about semantics. Unless you're calling this function a million times a second, you will not notice a performance difference, and even then the difference won't be significant.