文章地址: https://dzone.com/articles/java-getter-and-setter-basics-common-mistakes-and
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:
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:
Instead, the outside code has to invoke the getter, getNumber()
, and the setter, setNumber()
, in order to read or update the variable, for example:
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:
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:
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:
The following picture illustrates the situation:
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:
The appropriate setter and getter will be:
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:
The following table shows some examples of getters and setters which qualified for the naming convention:
Variable declaration |
Getter method |
Setter method |
int quantity
|
|
|
string firstName
|
|
|
Date birthday
|
|
|
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:
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:
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:
The following code demonstrates this problem:
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:
Line 3 will produce the following output:
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:
What will happen if we call the method displayScores()
again at line 5? Well, it will produce the following output:
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:
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:
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:
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:
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:
And then look at the following code snippet:
It will produce the following output:
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:
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
:
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:
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:
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:
Consider the following program:
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:
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:
Re-compile and run the CollectionGetterSetter
program; it will produce the desired output:
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:
It produces the following output when running:
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:
The setter for listPeople
is modified as follows:
The corresponding getter is modified, as shown below:
That results in a new version of the class CollectionGetterSetterObject,
shown below:
Compile and run the new version of CollectionGetterSetterObject
; it will produce the desired output:
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.
- Implement the
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:
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:
And for the getter method:
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!
Further Reading
Why Should I Write Getters and Setters?
相关推荐
99-智慧园区数据平台方案.pptx
Node.js,简称Node,是一个开源且跨平台的JavaScript运行时环境,它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立,旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎,可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型,这使得它非常适合处理大量并发连接,从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外,Node.js使用了模块化的架构,通过npm(Node package manager,Node包管理器),社区成员可以共享和复用代码,极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展,它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等,因此,开发者可以用JavaScript编写全栈应用程序,这一点大大提高了开发效率和便捷性。 在实践中,许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台,如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能,简化了开发流程,并且能更快地响应市场需求。
网络技术和计算机技术发展至今,已经拥有了深厚的理论基础,并在现实中进行了充分运用,尤其是基于计算机运行的软件更是受到各界的关注。加上现在人们已经步入信息时代,所以对于信息的宣传和管理就很关键。系统化是必要的,设计网上系统不仅会节约人力和管理成本,还会安全保存庞大的数据量,对于信息的维护和检索也不需要花费很多时间,非常的便利。 网上系统是在MySQL中建立数据表保存信息,运用SpringBoot框架和Java语言编写。并按照软件设计开发流程进行设计实现。系统具备友好性且功能完善。 网上系统在让售信息规范化的同时,也能及时通过数据输入的有效性规则检测出错误数据,让数据的录入达到准确性的目的,进而提升数据的可靠性,让系统数据的错误率降至最低。 关键词:vue;MySQL;SpringBoot框架 【引流】 Java、Python、Node.js、Spring Boot、Django、Express、MySQL、PostgreSQL、MongoDB、React、Angular、Vue、Bootstrap、Material-UI、Redis、Docker、Kubernetes
Excel工资条模板是一种预先设计好的电子表格文件,主要用于生成和打印员工的工资单,让员工清楚了解自己的工资组成和扣款详情。模板通常包含了以下几个关键部分: 1. **员工信息区**: - 姓名 - 员工编号/工号 - 部门 - 职位 2. **工资构成区**: - 基本工资 - 岗位工资 - 绩效奖金 - 加班工资 - 其他补贴(如交通补贴、餐补、全勤奖等) - 各项津贴(如高温补贴、取暖费等) - 其他应发收入(如年终奖、提成、福利等) 3. **扣款项目区**: - 社保扣款(养老保险、医疗保险、失业保险、工伤保险、生育保险) - 住房公积金 - 个人所得税 - 其他扣款(如迟到、旷工、违规罚款等) - 预借还款(如有) 4. **工资结算区**: - 应发工资总额 - 扣款总额 - 实发工资 5. **备注栏**: - 用于标注本月工资的特殊情况说明,如请假、调休、加班等情况。 6. **签名栏**: - 供员工确认工资数额无误后签名,也可以
29-【智慧城市与政府治理分会场】10亿大数据助推都市治理-30页.pdf
网络技术和计算机技术发展至今,已经拥有了深厚的理论基础,并在现实中进行了充分运用,尤其是基于计算机运行的软件更是受到各界的关注。加上现在人们已经步入信息时代,所以对于信息的宣传和管理就很关键。系统化是必要的,设计网上系统不仅会节约人力和管理成本,还会安全保存庞大的数据量,对于信息的维护和检索也不需要花费很多时间,非常的便利。 网上系统是在MySQL中建立数据表保存信息,运用SpringBoot框架和Java语言编写。并按照软件设计开发流程进行设计实现。系统具备友好性且功能完善。 网上系统在让售信息规范化的同时,也能及时通过数据输入的有效性规则检测出错误数据,让数据的录入达到准确性的目的,进而提升数据的可靠性,让系统数据的错误率降至最低。 关键词:vue;MySQL;SpringBoot框架 【引流】 Java、Python、Node.js、Spring Boot、Django、Express、MySQL、PostgreSQL、MongoDB、React、Angular、Vue、Bootstrap、Material-UI、Redis、Docker、Kubernetes
5G通信行业、网络优化、通信工程建设资料。
299-教育数据资产管理平台及配套解决方案.pptx
abababababababab
STM32学习软件编程资料,STM32F103C8单片机经典外设应用设计实例软件源代码,KEIL工程文件,可供学习参考。
5G通信行业、网络优化、通信工程建设资料。
5G通信行业、网络优化、通信工程建设资料
3M 轨道砂光机精英系列说明书
网络技术和计算机技术发展至今,已经拥有了深厚的理论基础,并在现实中进行了充分运用,尤其是基于计算机运行的软件更是受到各界的关注。加上现在人们已经步入信息时代,所以对于信息的宣传和管理就很关键。系统化是必要的,设计网上系统不仅会节约人力和管理成本,还会安全保存庞大的数据量,对于信息的维护和检索也不需要花费很多时间,非常的便利。 网上系统是在MySQL中建立数据表保存信息,运用SpringBoot框架和Java语言编写。并按照软件设计开发流程进行设计实现。系统具备友好性且功能完善。 网上系统在让售信息规范化的同时,也能及时通过数据输入的有效性规则检测出错误数据,让数据的录入达到准确性的目的,进而提升数据的可靠性,让系统数据的错误率降至最低。 关键词:vue;MySQL;SpringBoot框架 【引流】 Java、Python、Node.js、Spring Boot、Django、Express、MySQL、PostgreSQL、MongoDB、React、Angular、Vue、Bootstrap、Material-UI、Redis、Docker、Kubernetes
2023年亚太杯A题附件一,苹果图像数据集
5G通信、网络优化与通信建设
59-《煤矿测量规程(1989版)》150.pdf
5G通信行业、网络优化、通信工程建设资料。
由于当今全球气候变化异常,农作物病虫害频发,而且农作物病种类多,成因复杂,其预防和识别难度较大,且传统病虫害识别方法大多靠人目视手查,需要一定的专家经验,具有主观性强、识别准确率低等缺点.而信息技术作为解决农作物病虫害智能、快速识别的新技术、新方法,我们计划利用农业信息大数据智能决策分析系统,建立完善一体化的智能农业信息监测系统等.本文便是基于深度学习将计算机视觉、图像识别等技术运用于农作物病虫害检测中,开发智能病虫害检测系统,以提高病虫害检测准确率,减少病虫害对农业生产的危害