如何在Java中正确使用方法结果

Question

I will use result of a method call in some calculation. I have two ways:

1. Invoke method once and store the return into a local value, then use the local value in some calculation.

2. Use call method many times.

Please see my sample code:

public class TestMethod {

    public void doSomething_way1() {

        String prop1 = this.getProp1();
        if (prop1 != null) {
            String value = prop1 + " - another value";
            System.out.println(value);
        }
    }

    public void doSomething_way2() {

        if (this.getProp1() != null) {
            String value = this.getProp1() + " - another value";
            System.out.println(value);
        }   
    }

    public String getProp1() {
        return "return the same value";
    }
}

NOTE that, the method doSomething will be invoked a lots at a time ( In web environment )

Can someone show me which way I should use in the case the result of method will be used at least 3 times?

Answer 1

我相信多次使用方法调用会更直观，并使代码更具可读性。

Answer 2

In your case it wont matter even if you give call to the getProp1() method multiple times. Because it does not perform any computation, object creation or I/O operation which may cause performance issues.

Answer 3

You could go a step further:

public void doSomething_way2() {

    if (this.getProp1() != null) {
        System.out.println(this.getProp1() + " - another value");
    }

}

If the method is getting called a lot (I mean many, many times a second), creating the extra variable could change performance a tiny bit with respect to garbage collection and what not... I think its trivial.

Answer 4

In some cases, getting the value more than once could raise thread-safety issues, if the value weren't final , whereas if you fetch the value once, at least the entire operation of way1 will be consistent with a single value for prop1.

But even if threading weren't an issue, I still think it's better, stylistically, to 'cache' the value in a local variable which is well named.

(I'm assuming that your real code does something more significant than return the fixed String "something") - the getProp1 method as written is pretty thread-safe. :)

Answer 5

From a performance standpoint, at least from the examples given, it does not appear to be any fundamental difference doing it one way or another. Object allocations for small numbers of iterations (unless they are heavyweight objects) should be minimal.

However, from a programming design and implementation standpoint, it may be helpful to keep the program 'cohesive', ie have classes more closely represent things.

In which case the local variable from the return of the method (as it is a different 'thing') and subsequent calculation.

eg:

interface Dog{
    void wagTail();
    Dung eat(DogFood f);
}

interface Human{
    void pickUpDung(Dung d);
}

codeLoop(Human m, Dog d, DogFood f){
      d.wagTail();
      Dung poo = d.eat(f);
      m.pickUpDung(poo);
}

whereas a less cohesive example would be

interface Dog{
    void wagTail();
    void eatAndHaveHumanPickUp(DogFood f);
}
// you can fill in the rest...

it wouldn't follow the principle of cohesion, because you wouldn't normally expect a dog call to have this kind of method...