Java Getter and Setter: Basics, Common Mistakes, and Best Practices

kanpiaoxue

浏览: 1777077 次
性别:
来自: 北京

最近访客更多访客>>

zocmiu

rbaggio10

cheritor

guo_jinchen

博主相关

博客

微博

相册

留言

关于我

文章分类

社区版块

存档分类

博客分类：

经验
java

Getter and setter are widely used in Java. It is seemingly simple, but not every programmer understands and implements this kind of method properly. So in this article, I would like to deeply discuss getter and setter methods in Java — from the basics to common mistakes and best practices.

If you are already good with the basics, jump directly to section 4 where I talk about common mistakes and best practices.

You may also like: Why Should I Write Getters and Setters?

1. What Are Getter and Setter?

In Java, getter and setter are two conventional methods that are used for retrieving and updating the value of a variable.

The following code is an example of a simple class with a private variable and a couple of getter/setter methods:

 
 
 
 
public class SimpleGetterAndSetter {
    private int number;
​
    public int getNumber() {
        return this.number;
    }
​
    public void setNumber(int num) {
        this.number = num;
    }
}
 
 

The class declares a private variable, number. Since number is private, the code from the outside of this class cannot access the variable directly, as shown below:

 
SimpleGetterAndSetter obj = new SimpleGetterAndSetter();
obj.number = 10;    // compile error, since number is private
int num = obj.number; // same as above

Instead, the outside code has to invoke the getter, getNumber(), and the setter, setNumber(), in order to read or update the variable, for example:

 
SimpleGetterAndSetter obj = new SimpleGetterAndSetter();
​
obj.setNumber(10);  // OK
int num = obj.getNumber();  // fine

So, a setter is a method that updates the value of a variable. And a getter is a method that reads the value of a variable. Getter and setter are also known as accessor and mutator in Java.

2. Why Do We Need Getter and Setter?

By using getter and setter, the programmer can control how their important variables are accessed and updated in the proper manner, such as changing the value of a variable within a specified range. Consider the following code of a setter method:

 
public void setNumber(int num) {
    if (num < 10 || num > 100) {
        throw new IllegalArgumentException();
    }
    this.number = num;
}

This ensures that the value of the number is always set between 10 and 100. Suppose the variable number can be updated directly, the caller can set any arbitrary value to it:

 
obj.number = 3;

And that violates the constraint for values ranging from 10 to 100 for that variable. Of course, we don’t expect that to happen. Thus, hiding the variable number as private and then using a setter comes to the rescue.

On the other hand, a getter method is the only way for the outside world to read the variable’s value:

 
public int getNumber() {
    return this.number;
}

The following picture illustrates the situation:

Getter and setter visual

So far, the setter and getter methods protect a variable’s value from unexpected changes by the outside world — the caller code.

When a variable is hidden by the private modifier and can be accessed only through getter and setter, it is encapsulated. Encapsulation is one of the fundamental principles in object-oriented programming (OOP), thus implementing getter and setter is one of the ways to enforce encapsulation in the program’s code.

Some frameworks such as Hibernate, Spring, and Struts can inspect information or inject their utility code through getter and setter. So providing getter and setter is necessary when integrating your code with such frameworks.

3. Naming Convention for Getter and Setter

The naming scheme of setter and getter should follow the Java bean naming convention as getXxx() and setXxx(), where Xxx is the name of the variable. For example, with the following variable name:

 
private String name;

The appropriate setter and getter will be:

 
public void setName(String name) { }
​
public String getName() { }

If the variable is of the type boolean, then the getter’s name can be either isXXX() or getXXX(), but the former naming is preferred. For example:

 
private boolean single;
​
public String isSingle() { }

The following table shows some examples of getters and setters which qualified for the naming convention:

Variable declaration

Getter method

Setter method

int quantity

int getQuantity()

void setQuantity(int qty)

string firstName

String getFirstName()

void setFirstName(String fname)

Date birthday

Date getBirthday()

void setBirthday(Date bornDate)

boolean rich

boolean isRich()

boolean getRich()

void setRich(Boolean rich)

4. Common Mistakes When Implementing Getter and Setter

People often make mistakes, and developers are no exception. This section describes the most common mistakes when implementing setters and getters in Java, as well as workarounds.

Mistake #1: You have setter and getter, but the variable is declared in a less restricted scope.

Consider the following code snippet:

 
 
 
 
public String firstName;
​
public void setFirstName(String fname) {
    this.firstName = fname;
}
​
public String getFirstName() {
    return this.firstName;
}
 
 

The variable firstName is declared as public, so it can be accessed using the dot (.) operator directly, making the setter and getter useless. A workaround for this case is using more restricted access modifier such as protected and private:

 
private String firstName;

In the book Effective Java, Joshua Bloch points out this problem in item 14:

"In public classes, use accessor methods, not public fields."

Mistake #2: Assign object reference directly in the setter

Considering the following setter method:

 
private int[] scores;
​
public void setScores(int[] scr) {
    this.scores = scr;
}

The following code demonstrates this problem:

 
 
 
 
int[] myScores = {5, 5, 4, 3, 2, 4};
​
setScores(myScores);
​
displayScores();   
​
myScores[1] = 1;
​
displayScores();
 
 

An array of integer numbers, myScores, is initialized with 6 values (line 1) and the array is passed to the setScores() method (line 2). The method displayScores() simply prints out all scores from the array:

 
public void displayScores() {
    for (int i = 0; i < this.scores.length; i++) {
        System.out.print(this.scores[i] + " ");
    }
    System.out.println();
}

Line 3 will produce the following output:

 
5 5 4 3 2 4

These are all the elements of the myScores array. Now, in line 4, we can modify the value of the 2nd element in the myScores array as follows:

 
myScores[1] = 1;

What will happen if we call the method displayScores() again at line 5? Well, it will produce the following output:

 
5 1 4 3 2 4

You realize that the value of the 2nd element is changed from 5 to 1, as a result of the assignment in line 4. Why does it matter? Well, that means the data can be modified outside the scope of the setter method, which breaks the encapsulation purpose of the setter. And why does that happen? Let’s look at the setScores() method again:

 
public void setScores(int[] scr) {
    this.scores = scr;
}

The member variable scores are assigned to the method’s parameter variable scr directly. That means both of the variables are referring to the same object in memory — the myScores array object. So changes made to either the scores or myScores variables are actually made on the same object.

A workaround for this situation is to copy elements from the scr array to the scores array, one by one. The modified version of the setter would look like this:

 
public void setScores(int[] scr) {
    this.scores = new int[scr.length];
    System.arraycopy(scr, 0, this.scores, 0, scr.length);
}

What’s the difference? Well, the member variable scores is no longer referring to the object referred by the scr variable. Instead, the array scores is initialized to a new one with size equals to the size of the array scr. Then, we copy all elements from the array scr to the array scores, using System.arraycopy() method.

Run the following example again, and it will give us the following output:

 
5 4 3 2 4
5 4 3 2 4

Now, the two invocations of displayScores() produce the same output. That means the array scores is independent and different than the array scr passed into the setter, thus we have the assignment:

 
myScores[1] = 1;

This does not affect the array scores.

So, the rule of thumb is: If you pass an object reference into a setter method, then don’t copy that reference into the internal variable directly. Instead, you should find some ways to copy values of the passed object into the internal object, like we have copied elements from one array to another using the System.arraycopy() method.

Mistake #3: Return the object reference directly in getter

Consider the following getter method:

 
private int[] scores;
​
public int[] getScores() {
    return this.scores;
}

And then look at the following code snippet:

 
 
 
 
int[] myScores = {5, 5, 4, 3, 2, 4};
​
setScores(myScores);
​
displayScores();
​
int[] copyScores = getScores();
​
copyScores[1] = 1;
​
displayScores();
 
 

It will produce the following output:

 
5 4 3 2 4
1 4 3 2 4

As you notice, the 2nd element of the array scores is modified outside the setter, in line 5. Because the getter method returns the reference of the internal variable scores directly, the outside code can obtain this reference and make a change to the internal object.

A workaround for this case is that, instead of returning the reference directly in the getter, we should return a copy of the object. This is so that the outside code can obtain only a copy, not the internal object. Therefore, we modify the above getter as follows:

 
public int[] getScores() {
    int[] copy = new int[this.scores.length];
    System.arraycopy(this.scores, 0, copy, 0, copy.length);
    return copy;
}

So the rule of thumb is: Do not return a reference of the original object in the getter method. Instead, it should return a copy of the original object.

5. Implementing Getters and Setters for Primitive Types

With primitive types (int, float, double, boolean, char…), you can freely assign/return values directly in setter/getter because Java copies the value of one primitive to another instead of copying the object reference. So, mistakes #2 and #3 can easily be avoided.

For example, the following code is safe because the setter and getter are involved in a primitive type of float:

 
 
 
 
private float amount;
​
public void setAmount(float amount) {
    this.amount = amount;
}
​
public float getAmount() {
    return this.amount;
}
 
 

So, for primitive types, there is no special trick to correctly implement the getter and setter.

6. Implementing Getters and Setters for Common Object Types

Getters and Setters for String Objects:

String is an object type, but it is immutable, which means once a String object is created, its String literal cannot be changed. In other words, every change on that String object will result in a newly created String object. So, like primitive types, you can safely implement getter and setter for a String variable, like this:

 
 
 
 
private String address;
​
public void setAddress(String addr) {
    this.address = addr;
}
​
public String getAddress() {
    return this.address;
}
 
 

Getters and Setters for Date Objects:

The java.util.Date class implements the clone() method from the Object class. The method clone() returns a copy of the object, so we can use it for the getter and setter, as shown in the following example:

 
 
 
 
private Date birthDate;
​
public void setBirthDate(Date date) {
    this.birthDate = (Date) date.clone();
}
​
public Date getBirthDate() {
    return (Date) this.birthDate.clone();
}
 
 

The clone() method returns an Object, so we must cast it to the Date type.You can learn more about this in item 39 of Effective Java by Joshua Bloch:

"Make defensive copies when needed."

7. Implementing Getters and Setters for Collection Types

As described in mistakes #2 and #3, it’s not good to have setter and getter methods like this:

 
 
 
 
private List<String> listTitles;
​
public void setListTitles(List<String> titles) {
    this.listTitles = titles;
}
​
public List<String> getListTitles() {
    return this.listTitles;
}
 
 

Consider the following program:

 
 
 
 
import java.util.*;
​
public class CollectionGetterSetter {
    private List<String> listTitles;
​
    public void setListTitles(List<String> titles) {
this.listTitles = titles;
    }
​
    public List<String> getListTitles() {
        return this.listTitles;
    }
​
    public static void main(String[] args) {
        CollectionGetterSetter app = new CollectionGetterSetter();
        List<String> titles1 = new ArrayList();
        titles1.add("Name");
        titles1.add("Address");
        titles1.add("Email");
        titles1.add("Job");
​
        app.setListTitles(titles1);
​
        System.out.println("Titles 1: " + titles1);
​
        titles1.set(2, "Habilitation");
​
        List<String> titles2 = app.getListTitles();
        System.out.println("Titles 2: " + titles2);
​
        titles2.set(0, "Full name");
​
        List<String> titles3 = app.getListTitles();
        System.out.println("Titles 3: " + titles3);
​
    }
​
}
 
 

According to the rules for implementing getter and setter, the three System.out.println() statements should produce the same result. However, when running the above program, it produces the following output:

 
Titles 1: [Name, Address, Email, Job]
Titles 2: [Name, Address, Habilitation, Job]
Titles 3: [Full name, Address, Habilitation, Job]

For a collection of Strings, one solution is to use the constructor that takes another collection as an argument. For example, we can change the code of the above getter and setter as follows:

 
public void setListTitles(List<String> titles) {
    this.listTitles = new ArrayList<String>(titles);
}
​
public List<String> getListTitles() {
    return new ArrayList<String>(this.listTitles);   
}

Re-compile and run the CollectionGetterSetter program; it will produce the desired output:

 
Titles 1: [Name, Address, Email, Job]
Titles 2: [Name, Address, Email, Job]
Titles 3: [Name, Address, Email, Job]

NOTE: The constructor approach above is only working with Collections of Strings, but it will not work for Collections objects. Consider the following example for a Collection of the Person object:

 
 
 
 
import java.util.*; 
​
public class CollectionGetterSetterObject { 
    private List<Person> listPeople; 
​
    public void setListPeople(List<Person> list) { 
        this.listPeople = new ArrayList<Person>(list); 
    } 
​
    public List<Person> getListPeople() { 
        return new ArrayList<Person>(this.listPeople); 
    } 
​
    public static void main(String[] args) { 
        CollectionGetterSetterObject app = new CollectionGetterSetterObject(); 
​
        List<Person> list1 = new ArrayList<Person>(); 
        list1.add(new Person("Peter")); 
        list1.add(new Person("Alice")); 
        list1.add(new Person("Mary")); 
​
        app.setListPeople(list1); 
​
        System.out.println("List 1: " + list1); 
​
        list1.get(2).setName("Maryland"); 
​
        List<Person> list2 = app.getListPeople(); 
        System.out.println("List 2: " + list2); 
​
        list1.get(0).setName("Peter Crouch"); 
​
        List<Person> list3 = app.getListPeople(); 
        System.out.println("List 3: " + list3); 
​
    } 
} 
​
class Person { 
    private String name; 
​
    public Person(String name) { 
        this.name = name; 
    } 
​
    public String getName() { 
        return this.name; 
    } 
​
    public void setName(String name) { 
        this.name = name; 
    } 
​
    public String toString() { 
        return this.name; 
    } 
}
 
 

It produces the following output when running:

 
List 1: [Peter, Alice, Mary]
List 2: [Peter, Alice, Maryland]
List 3: [Peter Crouch, Alice, Maryland]

Because unlike String, for which new objects will be created whenever a String object is copied, other Object types are not. Only references are copied, so that’s why two Collections are distinct but they contain the same objects. In other words, it is because we haven’t provided any means for copying objects.

Look at the Collection API; we found that ArrayList, HashMap, HashSet, etc. implement their own clone() methods. These methods return shallow copies, which do not copy elements from the source Collection to the destination. According to the Javadoc of the clone() method of the ArrayList class:

public Object clone()
Returns a shallow copy of this ArrayList instance. (The elements themselves are not copied.)

Thus, we cannot use the clone() method of these Collection classes. The solution is to implement the clone() method for our own defined object — the Person class in the above example. We implement the clone() method in the Person class as shown below:

 
public Object clone() {
    Person aClone = new Person(this.name);
    return aClone;
}

The setter for listPeople is modified as follows:

 
public void setListPeople(List<Person> list) {
    for (Person aPerson : list) {
        this.listPeople.add((Person) aPerson.clone());
    }
}

The corresponding getter is modified, as shown below:

 
public List<Person> getListPeople() {
    List<Person> listReturn = new ArrayList<Person>();
    for (Person aPerson : this.listPeople) {
        listReturn.add((Person) aPerson.clone());
    }
​
    return listReturn;
}

That results in a new version of the class CollectionGetterSetterObject, shown below:

 
 
 
 
import java.util.*;
​
public class CollectionGetterSetterObject {
    private List<Person> listPeople = new ArrayList<Person>();
​
    public void setListPeople(List<Person> list) {
        for (Person aPerson : list) {
            this.listPeople.add((Person) aPerson.clone());
        }
    }
​
    public List<Person> getListPeople() {
        List<Person> listReturn = new ArrayList<Person>();
        for (Person aPerson : this.listPeople) {
            listReturn.add((Person) aPerson.clone());
        }
​
        return listReturn;
    }
​
    public static void main(String[] args) {
        CollectionGetterSetterObject app = new CollectionGetterSetterObject();
​
        List<Person> list1 = new ArrayList<Person>();
        list1.add(new Person("Peter"));
        list1.add(new Person("Alice"));
        list1.add(new Person("Mary"));
​
        app.setListPeople(list1);
​
        System.out.println("List 1: " + list1);
​
        list1.get(2).setName("Maryland");
​
        List<Person> list2 = app.getListPeople();
        System.out.println("List 2: " + list2);
​
        list1.get(0).setName("Peter Crouch");
​
        List<Person> list3 = app.getListPeople();
        System.out.println("List 3: " + list3);
​
    }
}
 
 

Compile and run the new version of CollectionGetterSetterObject; it will produce the desired output:

 
List 1: [Peter, Alice, Mary] 
List 2: [Peter, Alice, Mary] 
List 3: [Peter, Alice, Mary]

So, the key points for implementing getter and setter for a Collection type are:

For a Collection of String objects, it does not need any special tweak since String objects are immutable.
For a Collection of custom types of an object:
- Implement the clone() method for the custom type.
- For the setter, add cloned items from the source Collection to the destination one.
- For the getter, create a new Collection, which is being returned. Add cloned items from the original Collection to the new one.

8. Implementing Getters and Setters for Your Own Type

If you define a custom type of object, you should implement the clone() method for your own type. For example:

 
 
 
 
class Person {
    private String name;
​
    public Person(String name) {
        this.name = name;
    }
​
    public String getName() {
        return this.name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
​
    public String toString() {
        return this.name;
    }
​
    public Object clone() {
        Person aClone = new Person(this.name);
        return aClone;
    }
}
 
 

As we can see, the class Person implements its clone() method to return a cloned version of itself. Then, the setter method should be implemented like below:

 
public void setFriend(Person person) {
    this.friend = (Person) person.clone();
}

And for the getter method:

 
public Person getFriend() {
    return (Person) this.friend.clone();
}

So, the rules for implementing getter and setter for a custom object type are:

Implement a clone() method for the custom type.
Return a cloned object from the getter.
Assign a cloned object in the setter.

Conclusion

Java getter and setter seems to be simple, yet it can be dangerous if implemented naively. It could even be a source of problems that cause your code to misbehave. Or worse, one could easily exploit your programs by insidiously manipulating the arguments to, and returned objects from, your getters and setters. So, be careful and consider implementing the best practices mentioned above.

Hope you enjoyed!

最近访客更多访客>>

博主相关

文章分类

社区版块

存档分类

最新评论