1. Introduction
One of the choices that developers encounter is whether setter methods or constructors should be used to set the value of a variable. Both techniques have their benefits, however they are implemented in different situations.
In this tutorial, we’ll discuss when to use setter methods or constructors for setting the value of a variable in Java.
2. Using Setter Methods
Setter methods are functions that we can use to set the values of instance variables in a Java class. Additionally, they provide a flexible way to modify the state of an object after its initialization. Instance variables set using setter methods cannot be declared as final, as the values can be changed after object initialization.
Let’s consider a real-world example of a User class in a web application:
public class User {
private String username;
private String password;
public void setUsername(String username) {
// Validate username format
if (username.matches("[a-zA-Z0-9_]+")) {
this.username = username;
} else {
throw new IllegalArgumentException("Invalid username format");
}
}
// Other methods...
}
In this example, the User class encapsulates user data for a web application. The setUsername() and setPassword() setter methods allow the username and password to be set, respectively. These methods also perform validation to ensure that the username follows a specific format and the password meets certain strength criteria.
Let’s test the setter method and set the username for a User object:
@Test
void givenNewUser_whenSettingUsername_thenUsernameIsSet() {
User user = new User();
user.setUsername("john_doe");
assertEquals("john_doe", user.getUsername());
}
Here, we create a new User object using the default constructor User(), then we call the setUsername() method on the user object to set the username to “john_doe“. Finally, we use an assertion to verify that the username is correctly set.
3. Using Constructors
Constructors are special methods that allow us to initialize objects. They are called when an object of a class is created. Constructors can also be used to set the initial values of instance variables. One notable feature of constructors is that they allow for the initialization of final instance variables, ensuring that these values remain constant throughout the object’s lifecycle.
Let’s consider a real-world example of a Product class representing products in an e-commerce system:
public class Product {
private String name;
private double price;
private String category;
public Product(String name, double price, String category) {
this.name = name;
this.price = price;
this.category = category;
}
// Other methods...
}
In this example, the Product class represents products available for sale in an e-commerce system. The constructor Product(String name, double price, String category) initializes the name, price, and category of the product. By using a constructor, we ensure that essential information about the product, such as its name, price, and category, is set at the time of object creation.
To create a Product object with specific details using the constructor:
@Test
void givenProductDetails_whenCreatingProductWithConstructor_thenProductHasCorrectAttributes() {
Product product = new Product("Smartphone", 599.99, "Electronics");
assertEquals("Smartphone", product.getName());
assertEquals(599.99, product.getPrice(), 0.001);
assertEquals("Electronics", product.getCategory());
}
Here, we create a new Product object using the constructor Product(String name, double price, String category), passing the name, price, and category of the product as arguments directly during object creation.
4. Choosing Between Setters and Constructors
When deciding between setter methods and constructors, consider the following guidelines:
Use Setter Methods
|
Use Constructors |
| When the value of a variable may change over time |
When initializing immutable properties |
| When validation or additional logic is required before setting the value |
When ensuring that certain values are set at object creation time |
| When setting values after object initialization |
When the variable’s value should not change after initialization |
5. Conclusion
In conclusion, both setter methods and constructors are essential tools for setting variable values in Java. By understanding the differences and guidelines presented in this article, developers can make informed decisions about when to use setter methods or constructors effectively.
As usual, the accompanying source code can be found over on GitHub.
