在 Java 中将方法调用链接到构造函数是一个好习惯吗？

Question

I have always thought that I have to initialize a class, before I can call it's non-static method, however, I came across a solution which had a method like this in it:

public String someStringMethod(){
    return new MyClass().toString();
}

So I may be new in development, but is it a good practice? Is this a better way to call a method than the "classic" (see below) way?

public String classicStringMethod(){
    MyClass cl = new MyClass();
    return cl.toString();
}

Do they have any performance difference? Does the first way has a "special name"?

Answer 1

No significant difference

As the comments explained, both approaches are semantically the same; both ways achieve the exact same result and the choice is really just a stylistic difference.

The second approach assigns the new object to a reference variable. The first approach skips the use of a reference variable. But in both cases the class was used as a definition for instantiating an object, and then the toString method was called on that object.

Semantically, first (chained/fluent) syntax usually informs you that the created object will be used only for a single chain of operations, and discarded afterwards. Since there's no explicit reference exported, it also signals that the scope of life of the object is limited to that very statement. The second (explicit) one hints that the object is/was/will be used for additional operations, be it another method calls, setting a field to it, returning it, or even just debugging. Still, the general notion of using (or not) temporary helper variables is just a stylistic one .

Keep in mind that the variable is not the object. For example, the line Dog hershey = new Dog( "Australian Shepard" , "red", "Hershey" ); uses two chunks of memory. In one chunk is the new object, holding the state data for the breed and color and name. In the other separate chunk is the reference variable hershey holding a pointer to the memory location of the memory chunk of the Dog object. The reference variable lets us later refer to the object.

Java syntax makes this jump from reference variable to object so seamlessly that we usually think of hershey as the Dog object “Hershey”, but in fact they are separate and distinct.

As for performance, any difference would be insignificant. Indeed, the compiler or JVM may well collapse the second approach's two lines into the first approach's single line. I don't know for sure, and I don't really care. Neither should you. Our job is to write clear readable code. The job of the compiler and JVM is to run that code reliably, efficiently, and fast. Attempting micro-optimizations has been shown many times to be futile (or even counter-productive) as the JVM implementations are extremely sophisticated pieces of software engineering, highly-tuned for making such optimizations. You can best assist the compilers and JVMs by writing simple straight-forward code without “cleverness”.

Note that the second approach can make debugging easier, because your debugger can inspect the instantiated object by accessing the object via the reference variable, and because you can set a line breakpoint on that particular constructor call explicitly.