1

Is there a reason to prefer using shared instance variable in class vs. local variable and have methods return the instance to it? Or is either one a bad practice?

import package.AClass;

public class foo {
    private AClass aVar = new AClass();

    // ... Constructor

    public AClass returnAClassSetted() {
     doStuff(aVar);

     return avar;
    }

    private void doStuff(AClass a) {
     aVar = a.setSomething("");
    }
}

vs. 

import package.AClass;

public class foo {

    // ... Constructor

    public AClass returnAClassSetted() {
     AClass aVar = new AClass();
     aVar = doStuff();

     return aVar;
    }

    private AClass doStuff() {
     AClass aVar1 = new AClass();
     aVar1.setSomething("");

     return aVar1;
    }
}

First one makes more sense to me in so many ways but I often see code that does the second. Thanks!

Improve this question
4
  • It really depends on the task at hand... Commented Aug 12, 2015 at 17:47
  • Instance variables should be used for object state. That is, information that needs to remain around in the object between accesses to its methods. Information scope should be as small as possible. Commented Aug 12, 2015 at 17:51
  • 1
    Please fix your code to make it readable. There is no Class keyword in java, there is no AVar1 variable. Java is case sensetive. Commented Aug 12, 2015 at 17:51
  • Oops, sorry. I fixed that. Commented Aug 12, 2015 at 17:54

5 Answers 5

Reset to default
2

Instance variables are shared by all methods in the class. When one method changes the data, another method can be affected by it. It means that you can't understand any one method on its own since it is affected by the code in the other methods in the class. The order in which methods are called can affect the outcome. The methods may not be reentrant. That means that if the method is called, again, before it finishes its execution (say it calls a method that then calls it, or fires an event which then a listener calls the method) then it may fail or behave incorrectly since the data is shared. If that wasn't enough potential problems, when you have multithreading, the data could be changed while you are using it causing inconsistent and hard to reproduce bugs (race conditions).

Using local variables keeps the scope minimized to the smallest amount of code that needs it. This makes it easier to understand, and to debug. It avoids race conditions. It is easier to ensure the method is reentrant. It is a good practice to minimize the scope of data.

Improve this answer
Sign up to request clarification or add additional context in comments.

1 Comment

I see, so if I have the doStuff method of the second option public; calling both methods outside would ensure that the two aren't overwriting the same object. Whereas the first case would be used if I want one method to overwrite the same object.
0

Your class name should have been Foo.

The two versions you have are not the same, and it should depend on your use case.

The first version returns the same AClass object when different callers call returnAClassSetted() method using the same Foo object. If one of them changes the state of the returned AClass object, all of them will get see the change. Your Foo class is effectively a Singleton.

The second version returns a new AClass object every time a caller calls returnAClassSetted() method using either the same or different Foo object. Your Foo class is effectively a Builder.

Also, if you want the second version, remove the AClass aVar = new AClass(); and just use AClass aVar = doStuff();. Because you are throwing away the first AClass object created by new AClass();

Improve this answer

Comments

0

It's not a yes/no question. It basically depends on the situation and your needs. Declaring the variable in the smallest scope as possible is considered the best practice. However there may be some cases (like in this one) where, depending on the task, it's better to declare it inside/outside the methods. If you declare them outside it will be one instance, and it will be two on the other hand.

Improve this answer

Comments

0

Instance properties represent the state of a specific instance of that Class. It might make more sense to think about a concrete example. If the class is Engine, one of the properties that might represent the state of the Engine might be

private boolean running;

... so given an instance of Engine, you could call engine.isRunning() to check the state.

If a given property is not part of the state (or composition) of your Class, then it might be best suited to be a local variable within a method, as implementation detail.

Improve this answer

Comments

0

In Instance variables values given are default values means null so if it's an object reference, 0 if it's and int.

Local variables usually don't get default values, and therefore need to be explicitly initialized and the compiler generates an error if you fail to do so.

Further, Local variables are only visible in the method or block in which they are declared whereas the instance variable can be seen by all methods in the class.

Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.