CODEWITHSUNDEEP
javavariablesdeclaration
Maximus
Maximus

Reputation: 241

Java variable declaration

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.

Upvotes: 1

Views: 1025

Answers (8)

Endophage
Endophage

Reputation: 21483

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.

Upvotes: 2

Mike Samuel
Mike Samuel

Reputation: 120576

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.

Upvotes: 2

jmq
jmq

Reputation: 10370

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.

Upvotes: 0

Piyush Mattoo
Piyush Mattoo

Reputation: 16153

  • 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.

Upvotes: 1

Péter Török
Péter Török

Reputation: 116306

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.

Upvotes: 3

Jordan Allan
Jordan Allan

Reputation: 4486

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);

Upvotes: 1

Foxfire
Foxfire

Reputation: 5765

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.

Upvotes: 1

Falmarri
Falmarri

Reputation: 48605

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

Upvotes: 0

Related Questions