Accessor Methods in Java

Question

So I have a question on \"setter\" and \"getter\" methods and how useful they are or aren\'t.

Let\'s say I just write a very basic program like the following:

<

Answer 1

If your code never changes then you're right - there is no difference.

However, code changes a lot. What happens if you need to keep track of who has modified their name?

You would need to have a boolean in the Account class that would change to true whenever the name field has changed.

So now you have to go through every source file and put a

myAccount.nameChanged = true' under each

myAccount.name = whatever;

So you start having code duplication and the possibility for bugs increases. What happens if I missed a name change?

The best way to counteract this is to have member variables classified as private.

Your setName code would look something like this:

public void setName(String newName)
{
    name = newName;
    nameChanged = true;
}

And you don't have to worry about bugs!

Answer 2

As a matter of fact it doesn't prevent and there's no difference until you change access modifiers for getter/setter methods or add additional logic into them. The latter not always a good idea but sometimes helps, for example updating the name should force updating some cached value or performing some checks as a result. Using getters/setters are a good practice and used in several approaches like POJOs and JavaBeans but if you are not going to add custom logic into getters/setters and are not going to use these approaches you will be satisfied of using direct access to the fields.

One thing I'd like to mention. Using getters/setters you can provide computed at the runtime fields that do not exists persistently in the object. For example your Account class's object holds birth date and you need to get the age of it.

Answer 3

This is called Encapsulation when you are declaring some private instance variables and declaring public getter and setter method to access and change the instance variables value.

If you are using these getter and setter methods to access/set instance variables then it grantees that your program would not fail if developer changes the instance variable names.

For example in current version you are using name, address, balance Instance variables and are accessing them without getter and setter methods like myAccount.setName("Blah blah"); but what if next version developer changes instance variable name from name to userName in that case user program will break but if you are using getter and setter it would not break as developer would not change getter and setter method name(according to OOPS fundamentals).

Answer 4

The advantage of using setters ans getters is that you can include rules for lazy initialization, validation, etc. Also, if you need to implement Java Beans complaint code, you need to follow those rules.

Java Beans spec

Answer 5

You can always develop an application without using getter and setter methods.As you have explained.But using getter and setter is better practice because access modifiers private/public gives you encapsulation which is OOPS feature. You can always write your program without using OOPS features like encapsulation,abstraction,inheritance...but if you write large applications without using you will have trouble in maintaining and would soon realize the importance of these features.

Answer 6

With trivial accessor methods, there is no difference except style, but you can also execute code with them, for example:

public void setName(String name) {
    if (name == null) {
        throw new IllegalArgumentException("Name may not be null");
    }
    this.name = name;
}

You can also return copies from a getter, thus protecting your data:

private List<String> middleNames;
public List<String> getMiddleNames() {
    return new ArrayList<String>(middleNames); // return a copy
    // The caller can modify the returned list without affecting your data
}

These are just two simple examples, but there are limitless examples of how accessor methods can be used.

It is better to follow a consistent style, so that's why we always use getters/setters - so code this like may be executed if needed.