Wrapping simple statement in a function in java?

Do not do this. You are simply renaming the function to fit your personal preconceptions. Some future maintainer will have to learn neo4j, and will know the meaning of getReferenceNode. Then she will see calls to getRootNode and think "getRootNode? WTF is that?" Then she will go read your function, and grab something and throw it against the wall cursing your name. Then she will refactor, inlining getRootNode out of existence.

We introduce functions to reduce duplication and maintenance cost. Your function does the opposite.

Someone made a choice to use neo4j. Learn it and use it as designed.

This looks to me like the Java equivalent of creating a C/C++ macro to save typing a few letters, which I can't accept as a good practice. You'll be re-reading the code far more often than you will write it, so the "additional level of indirection" you've added will cost far more time in maintenance than you will save in development.

A classic example of premature optimization. When writing code you must feel free to add all the structure you see fit. Later, a profiler will tell you where you need to optimize.

SO my question is am i right in thinking that doing above mentioned thing is inefficient? or it does not affect performance that much?

If you are mostly worried about performance, then put each variant in a separate loop, run through it a million or somesuch amount of times, and measure the time difference between executing the two variants. Chances are the difference will be negligible to nonexistent.

If you look at the byte code, I wouldn't be at all surprised if the entire function is inlined by the compiler, since all it does is wrap another call.

In modern Java, function calls are practically free. If it is called rarely, you won't notice the overhead. If it gets called frequently, the JIT will inline the call, eliminating any overhead.

Think about it again.

1. YAGNI - You ain't gonna need it. Do you really need to wrap the function? How often and in how many places do you resolve a root node - and most importantly - do you expect to add additional behaviour to this method later on?

2. Does it really improve readability? This is highly subjective. In my eyes, both variants are almost equal in readability. I'd even prefer the first one if I don't really need the wrapper because I don't want to add behaviour later on, as it's easier to debug, one less level to step through.

3. Performance This is a minor concern here. I doubt you call that method very often. When you call it in a loop, it could have a severe impact on performance. The overhead itself is negligible for single function calls.

4. Design Decision Do you want to hide the graphDB Member completely, i.e. behind an interface? Then by all means create a whole abstraction of it with all the methods necessary.

That said, the increased readability is highly subjective (in your eyes only) while adding a new layer that could potentially lead to a performance loss. That's fine if you need that wrapper because you expect to add additional behaviour later on and your code is sprinkled wich calls of getReferenceNode(). If you just have a single call or very few calls of getReferenceNode and you don't plan to add additional behaviour later, then I'd not create that wrapper.

Use a profiler to test this. Sometimes, it's better to increase readability if there's not such a great performance penalty.