在没有Java数据的情况下创建没有数据的对象而不是使用静态方法会花费多少钱？

Question

Java lacks the ability to specify interfaces for static methods. A method in an interface must be non static. This makes it impossible to specify requirements for Classes. Instead one is limited to specify requirements for Objects. This makes it also impossible for example to specify the singleton functionality in an interface, because in Java the singleton pattern requires to be implemented as a static method. Here is a nice article, which explains it, but it is only in German.

When one is forced to implement something as a functionality of an object instead of the functionality of a class, an instance of this object has to be created, before the functionality can be used. But such object has some special characteristic: it has no state, because class functionality has no state either. Theoretically the instance creation of an object without data can be optimized to an NOP , because all methods can be linked to the class instead of any object. Java could implement some kind of implicit singleton functionality.

But how it this actually handled?

Think about some kind of functionality without any state.

interface Adder<T> { T add(T ... arguments); }

Basically it would be sufficient to implement this as a static method:

class IntegerAdder implements Adder<Integer> {
   public static Integer add (Integer ... arguments) { }
}

But because Java does not allow static interface methods it has to be implemented in a non static way. The result is, that when ever an IntegerAdder is required one has to create an instance.

IntegerAdder integer_adder = new IntegerAdder();
Integer a = 1;
Integer b = 2;
Integer c = integer_adder.add (1, 2);

I fear this might be slower than the version without the instance creation:

Integer a = 1;
Integer b = 2;
Integer c = IntegerAdder.add (1, 2);

But how much slower is it in reality? Is it possible for the Java compiler to optimize the first version in that way that it performs as fast as the second one? And is this actually done?

Answer 1

You can create an instance of IntegerAdder once and reuse it, it is thread safe. Also pay attention that Integer ... arguments leads to 1) using objects instead of primitive ints 2) creating an array to pass parameters. Both things should be avoided if performance is concern