CODEWITHSUNDEEP
javaoop
Mike
Mike

Reputation: 17

Object Oriented, passing variables or using object state

Hi apologies for the basic question, im sure I've been told the answer before and I've spent some time searching but couldn't find a good answer (probably because its hard to phrase as a search query), I've done a little bit of OO programming before but ive done a lot of procedural stuff recently so that seems to be clouding my thoughts.

I have a program that has to work with strings, part of that program involves sanitising a string, so I have this method:

private void sanitizeString() {
    removeEscape();
    removePunctuation();
    removeCaps();
}

And earlier in the class declared the variable

String x = "... some string ..."

In procedural you would obviously pass all of the functions the string that they need to work on, my question is in OO is it ok to have this string declared at the top of the class and then just do something like 

private void removeCaps() {
    x = x.toLowerCase();
}

or should it be

private String removeCaps(String y) {
    y = y.toLowerCase();
    return y;
}

I think this it should be the first way, and I know that that works ok, but im doing something that has to demonstrate good OO so I just want to check I have my basic assumptions right.

Thanks

Upvotes: 0

Views: 241

Answers (3)

Yogendra Singh
Yogendra Singh

Reputation: 34367

Since x is declared as class variable, this one is fine:

  private void removeCaps() {
        x = x.toLowerCase();
  }

as class variables are accessible inside class methods and you don't need to pass the class variables as arguments to same class methods

Same class variables are accessed this way only. Very simple example could be POJO classes, where you declare class variables and expose them through getter/setter methods. You don;t need to pass the class variables to these methods and some time, you can't(e.g. in getter methods).

Adding some thoughts around class variable vs. local variable in the method.

  1. If there is a need of a variable which is theoretically associated with the class definition then the variable should be defined as class variable. e.g. employeeId, employeeName.. variables in a employee class should be defined as Employee class variables.

  2. If there are variable needs which are local to a class method only and not required anywhere outside the method/class, then it should be defined as local variable inside the method.

  3. If you are defining some utility methods to respond using some variables then those variables should be passed as argument to the util methods.

Back to your question:

If you are defining a entire class e.g. Sanitising, which has several methods around the string variable e.g. String class itself, then better to define your string as class variable and write the methods using the class variables.

But if you are defining Sanitising as a util/helper class then better to pass the string as method argument as normally you don;t want your util methods to be statefull (associated with the class instance).

Upvotes: 0

Code-Apprentice
Code-Apprentice

Reputation: 83527

You have a trade off here:

  1. Declaring the variable as a class variable means that you must create a new object for each String you want to sanitize.

  2. Passing the String variable to each method means that you can reuse the same object to sanitize multiple Strings.

You must weigh the advantages and disadvantages of each approach to decide which is most appropriate for your particular situation.

Upvotes: 1

Martin Seeler
Martin Seeler

Reputation: 6982

To demonstrate good OO, you should definitly use 

private String removeCaps(String y) {
    return y.toLowerCase();
}

You can pass your Object, in this case your String in the global field x to the method as parameter. The String is then in the local field y and return the modified version.

Upvotes: 0

Related Questions