1

Ok, this might be basic, but I want good programmers' opinions on this.

What is a good way to handle variables in a small class file?

I like modularizing methods and keeping methods that do really specific things. I end up passing variables between those methods. Is it a good practice to make variables used across many methods as member variables? Or is it better to pass the variables to methods?

For example: 

class Test{
    somefunction(int a, int b, int c, int d) {
        doSomething(a, b, c);
        doOneMoreThing(a, c, d);
    }
    void doSomething(int a, int b, int c) { }
    void doOneMoreThing(int a, int c, int d) { }
 }

In the above example, do you think the variables should be kept as member variables? Please explain why one methodology is preferred over the other.

Improve this question

8 Answers 8

Reset to default
3

Do you need to keep the variables around between method calls, and reuse their value? If so, they should be class members. (At least in some class - not necessarily this one.)

Otherwise it is somewhat a matter of taste. One important factor is though that local variables don't add state to the object, which can be useful if it is used concurrently. Keeping all variables local may even allow you to make your class immutable, which usually makes it automatically thread-safe. But even in a single-threaded environment an immutable class is easier to understand and maintain.

OTOH passing lots of parameters around can be awkward. You may consider introducing a Parameter Object to alleviate this problem.

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

Comments

2

If I have some variables that I would end up passing to a bunch of private methods, I'll often move them into a private inner worker class.

Instead of

class Foo {
  public doSomething(...) {
    // some setup
    doSomethingRecursively(a, b, c);
  }

  private void doSomethingRecursively(A a, B b, C c) {
    if (baseCase) { ... }
    doSomethingRecursively(a + 1, b, c);
  }
}

I'll move the variables that never difference into properties on a worker.

class Foo {
  public doSomething(...) {
    // some setup
    new AppropriatelyNamedHelper(b, c).doSomethingRecursively(a);
  }

  private static final class AppropriatelyNamedHelper {
    final B b;
    final C c;

    AppropriatelyNamedHelper(B b, C c) {
      this.b = b;
      this.c = c;
    }

    void doSomethingRecursively(A a) {
      if (baseCase) { ... }
      doSomethingRecursively(a + 1);
    }
  }
}

This makes it clear to a reviewer what in each scope is invariant within that scope.

Improve this answer

Comments

2

Member variables should exist to maintain some kind of state in a class. If your class maintains state then definitely define member variables for those things you need to track. If a class does not maintain state then there is no reason to make things members (I have had to debug legacy code where variables should not have been made members but were and it was causing errors when making multiple calls to the object because the state was unpredictable).

However, while you might like "modularizing" functionality, read up on coupling vs. cohesion. There is a balance to be struck between having too much functionality in a class but fewer dependencies and having very little but highly specific functionality and lots of dependencies.

Improve this answer

1 Comment

Thanks, I will read the coupling vs. cohesion to better understand this!
1

Having useless member variables is usually regarded to as bad design. But you can (and should) combine multiple variable sets into a new class if you use that variables in lots of methods.

Improve this answer

Comments

1

If you don't care about the state of the object, then passing the variables to the method is fine. In that case, I would use a static modifier on the method, then you don't have to instansiate the class and you can call the method like so:

Test.doSomething(1, 2, 3);
Improve this answer

Comments

1
  • Instance Variables: Their values are unique to each instance of a class. When an object is allocated in the heap, there is a slot in it for each instance variable value. Therefore an instance variable is created when an object is created and destroyed when the object is destroyed.
  • Class Variable: The Class variables are declared with a static keyword/modifier.There is only one copy of class variable no matter how many times the class is instantiated. They are stored in static memory.
  • Local variables: Only accessible within the method they are declared. When a method is entered, an area is pushed onto the call stack. This area contains slots for each local variable and parameter. When the method is called, the parameter slots are initialized to the parameter values. When the method exits, this area is popped off the stack and the memory becomes available for the next called method.

If you are going to reuse the variables, then you can declare them as class variables. If not, then they should be local variables defined in their respective methods.

Improve this answer

Comments

0

First of all Somefunction(... } is a syntax error. Second, method names should start with lower case letters, and class names should start with upper case. Third, we have no idea what the best way is without knowing what these methods do, what they're used for, and where their parameters come from

Improve this answer

2 Comments

well, I didn't think anyone would look for syntax errors, I wasn't trying to debug the code here. That was just an example, which would make people better understand what I am looking for. If you have read the question/replies, you would know that you won't need to know the function details to answer it :)
@Maxius: That's why you should post the minimum, compilable amount of code that demonstrates your problem. Also, your question is subjective, so there really wasn't enough information to give you an answer anyway.
0

Depends on how often you have to change your code (or you should think about how often you're going to change it when you design it). If the signature changes you have to change it in a lot of places. That means more code to test even when you refactor the signature. I would err on the side of creating member variables and encapsulating.

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.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.