Constructors in Java Explained

Constructors in Java Explained

9 mins read17.3K Views Comment
clickHere
Atul
Atul Harsha
Senior Manager Content
Updated on Sep 22, 2023 12:35 IST

In Java, constructors initialize newly created objects, setting their initial state. They share the same name as the class, lack a return type, and are automatically invoked upon object instantiation.

2022_05_Copy-of-Feature-Image-Templates-12.jpg

A constructor in Java is a special type of method that is used to initialize an object. It is called when an instance of an object is created and memory is allocated for the object. This article goes through the concepts of Constructors in Java programming language. In addition, it covers the types of constructors–Default, No-argument, Parameterized, and Copy constructors with examples.

Table of Content

What is Constructor in Java?

A constructor is a special member function of a class with the same name as the class name but has no return type. Whenever an object of a class is created using a new keyword, it invokes a constructor of that class.

Key Features of Constructors in Java

Here are some key points about constructors in Java:

  1. Name: The constructor has the same name as the class in which it resides.
  2. No Return Type: Constructors do not have a return type, not even void.
  3. Purpose: The primary purpose of a constructor is to initialize the newly created object.
  4. Default Constructor: If you do not define any constructor in your class, the Java compiler inserts a default constructor into your code on your behalf. This default constructor is called when an object of the class is instantiated.
  5. Parameterized Constructor: These are constructors with parameters. If you define a parameterized constructor, you need to instantiate the class with the same number of arguments as there are parameters.
  6. Constructor Overloading: Just like method overloading in Java, a class can have multiple constructors, but they must have a different parameter list.
  7. Private Constructors: If a constructor is made private, then the class cannot be instantiated from outside the class. This approach is primarily used in the Singleton design pattern.
  8. Constructor Chaining: In Java, a constructor can call another constructor in the same class using this() keyword. This is known as constructor chaining.
  9. Invoking Base Class Constructor: If a class is derived from another class, the derived class has a chance to call the constructor of its base class. This is done using the super() keyword.

Constructor in Java Syntax:

 
<strong>class</strong> Class_Name
{
.......
<em>// Constructor created</em>
Class_Name([parameter_list]) <em>//constructor Definition</em>
{
. . . .
<em>//declaration</em>
}
.......
}
<strong>class</strong> Class_Name_Main
{
<strong>public</strong> <strong>static</strong> <strong>void</strong> main(String[] args)
{
<em>//object created using new keyword</em>
<em>//object creation invokes the respective class</em>
<em>//And calls the constructor of that class.</em>
Class_Name Class_Object = <strong>new</strong> Class_Name();
. . . . . .
}
}
Copy code

Example:

 
public class NumberHolder {
private int number;
// Default constructor initializes number to a default value
public NumberHolder() {
this.number = 10;
}
// Parameterized constructor initializes number to the provided value
public NumberHolder(int number) {
this.number = number;
}
// Getter method for number
public int getNumber() {
return number;
}
public static void main(String[] args) {
NumberHolder holder1 = new NumberHolder(); // Calls default constructor
NumberHolder holder2 = new NumberHolder(20); // Calls parameterized constructor
System.out.println("Value of holder1's number: " + holder1.getNumber());
System.out.println("Value of holder2's number: " + holder2.getNumber());
}
}
Copy code

In the refined example, when we instantiate holder1 using the default constructor, the number attribute is initialized to 10. For the holder2 instance, we employ the parameterized constructor, assigning number a value of 20. Notably, NumberHolder() acts as a constructor, bearing the same name as its class and devoid of a return type.

Constructors in Java – Explained with Scenario

User Account Creation in a Web Application

Imagine you’re developing a web application for a bank. One of the core features is user account creation and management.

1. Class Definition

What: Define a User class representing a bank customer.

 
public class User {
private String username;
private String password;
private String email;
private Date dateOfBirth;
// ... other attributes like address, phone number, etc.
}
Copy code

Why: The class serves as a blueprint for user data. It encapsulates the attributes and behaviours associated with a user, ensuring data consistency and integrity.

2. Initialization with Constructor

What: Create a new User object when a user signs up.

 
public User(String username, String password, String email, Date dateOfBirth) {
this.username = username;
this.password = encryptPassword(password); // Assume encryption for security
this.email = email;
this.dateOfBirth = dateOfBirth;
}
Copy code

Why: Proper initialization ensures that every user object has a consistent state when created. Encrypting the password at this stage enhances security.

3. Default Constructor

What: Provide a default way to create a User object.

 
public User() {
// Default constructor
}
Copy code

Why: Frameworks like Hibernate require a default constructor for object-relational mapping. It also offers flexibility for developers to instantiate an object and set its attributes later.

4. Parameterized Constructor for Partial Initialization

What: Allow users to sign up with minimal details.

 
public User(String username, String email) {
this.username = username;
this.email = email;
// Other attributes might be set later
}
Copy code

Why: Enhancing user experience by providing a quick sign-up option can increase user registration rates. This constructor caters to that scenario, allowing for additional details to be filled in later.

5. Constructor Overloading

What: Provide multiple ways to create a User object based on different scenarios.

Why: Different user registration scenarios may require different data. Overloading constructors allow the application to handle various use cases without compromising data integrity.

6. Special Constructors for Admin Functionalities

What: Allow admins to create and verify users directly.

 
public User(String username, String email, boolean isVerified) {
this.username = username;
this.email = email;
this.isVerified = isVerified;
}
Copy code

Why: Admins might need enhanced functionalities compared to regular users. This constructor ensures that admins can create users with specific attributes, streamlining administrative tasks.

Perspective:

In a production and development environment, constructors play a pivotal role in:

  • Data Integrity: Ensuring that objects are always in a valid state when instantiated.
  • Flexibility: Catering to various use cases by allowing different ways to create objects.
  • Security: Encrypting sensitive data, like passwords, right from the object’s creation.
  • Maintainability: Having clear and distinct constructors makes the code easier to understand and maintain.
  • Enhanced User Experience: By providing quick sign-up options or other user-centric features.

Constructors, when designed with these perspectives in mind, can significantly improve the robustness and efficiency of an application.

Types of Constructors in Java

In a real-world development scenario. There are 3 types of Constructors in Java. Let’s learn about each type one by one.

  • The Default Constructor can be handy when you want to instantiate a user object without immediately setting its attributes, perhaps for temporary or guest users.
  • The Parameterized Constructor is essential for creating user objects with specific details, ensuring that the object is correctly initialized from the start.
  • The Copy Constructor is beneficial when you need a duplicate of an existing user object, ensuring that the new object is an exact copy of the original.

Using these constructors effectively can streamline the object creation process, maintain data integrity, and enhance the application’s flexibility.

2022_05_image-17.jpg

1. Default Constructor (No-Argument Constructor)

A default constructor is one that doesn’t take any arguments. It’s also called a no-argument constructor. If not provided, the Java compiler will automatically generate one for you.

Example:

What: You’re creating a temporary profile for users who just want to browse the bank’s services without committing to a full registration.

 
public User() {
// Default values or initializations can be set here
this.username = "Guest";
this.email = "guest@example.com";
}
Copy code

Why: By using the default constructor, you can quickly instantiate a generic user object with default attributes, allowing guests to explore the application without providing personal details.

2. Parameterized Constructor

A parameterized constructor takes arguments to initialize the object’s attributes.

In addition, these types of constructors are usually used for constructor overloading to differentiate between multiple constructors with different datatypes.

Example:

What: A new customer wants to register for online banking and provides their username, password, email, and date of birth during the sign-up process.

 
public User(String username, String password, String email, Date dateOfBirth) {
this.username = username;
this.password = password; // In a real scenario, you'd encrypt this
this.email = email;
this.dateOfBirth = dateOfBirth;
}
Copy code

Why: The parameterized constructor is essential here because it allows you to create a User object with the specific details the customer provided, ensuring accurate data representation and immediate initialization.

3. Copy Constructor

A copy constructor is used to create an exact copy of an object. It takes an object of the same class as a parameter and copies its attributes.

Example:

What: The bank is migrating user data to a new system, and they want to create a backup of user profiles in the process.

 
public User(User originalUser) {
this.username = originalUser.username;
this.password = originalUser.password;
this.email = originalUser.email;
this.dateOfBirth = originalUser.dateOfBirth;
}
Copy code

Why: In this scenario, the copy constructor is invaluable. It lets you create an exact replica of an existing user object, ensuring data consistency during the migration process without altering the original data.

Also Read: Top Java Interview Questions

Difference between Java Constructor and Java Method

Java constructors and methods are completely two different things. Let’s understand the difference between a constructor and a method in Java.

Feature Java Constructor Java Method
Purpose Sets up a new user profile with initial details. Performs actions like updating profile, checking user activity, or deleting an account.
Real-Life Example Registering a new user on a website. Changing user password or checking the user’s purchase history.
What Initializes a user profile with details like username, email, and date of registration. Represents actions like changing email, updating profile picture, or logging user activity.
Why Ensures every user profile starts with essential details, ready for use. Provides ways to interact with the user profile, modify its details, or retrieve specific information.
Name Must match the class, e.g., UserProfile. Can be descriptive of the action, e.g., changePassword, updateEmail.
Return Type No return type. Can return details like a boolean for successful updates or a String for retrieving profile details.
Call Invoked once when a new user profile is created. Called whenever a specific action on a user profile is needed.
Keyword No specific keyword. Uses data type of the return value, e.g., void, int, String.
Usage Used once per user profile creation. Can be called multiple times, e.g., every time a user updates their details.
Modifiers Cannot have abstract, final, static, etc. Can have modifiers like public, private, static, final, etc.
Overloading Can have multiple constructors with different parameters for varied registration methods. Can have multiple methods with the same name but different parameters, e.g., updateProfile(String email), updateProfile(String email, String phoneNumber).
Inheritance Not inherited but can be called in a derived class using super() . Can be inherited in subclasses and can be overridden to provide specific implementations.
An Introduction to “this” Keyword in Java
An Introduction to “this” Keyword in Java
The article below explains the usage of this keyword in java with suitable examples and descriptions.
What is Wrapper Class in Java?
What is Wrapper Class in Java?
This article will teach you what is wrapper class and how wrapper objects are created. It will also teach you the concept of autoboxing and unboxing in java.
Java Methods Explained (with Code)
Java Methods Explained (with Code)
The below java tutorial covers java methods with examples and explanations. It also goes through the declaration, implementation, types, and its uses.

In Conclusion

Constructors in Java play a pivotal role in software development, ensuring that objects are consistently and correctly initialized. Their integral function in setting an object’s initial state makes them indispensable for building robust and efficient applications.

FAQs

What is Java?

Java is one of the most popular object-oriented programming languages that help to solve complex real-world problems using OOP concepts. Java is widely used due to its robustness and high performance.

What is constructor in Java?

In Java, a constructor is a special method of a class or structure which is used to initializes a newly created object. The constructor is automatically called whenever an object is created.

What are different types of constructors in Java?

In Java, constructors can be divided into 4 types: No-Argument Constructor. Parameterized Constructor. Default Constructor, and copy constructor.

What is Constructor Overloading?

Declaring multiple constructors with same name and different number of parameters within a same class is known as constructor overloading

How to identify a constructor in the code?

Constructor name is always same as that of the class name. Compiler uses this character to differentiate constructors from the other member functions of the class.

Why constructors do not return any values?

A Constructor doesn't return a value is because it is not directly called by your code. It is called by the memory allocation and object initialization code during the runtime. Its return value is not available to the user and hence, you can't specify it.

About the Author
author-image
Atul Harsha
Senior Manager Content

Experienced AI and Machine Learning content creator with a passion for using data to solve real-world challenges. I specialize in Python, SQL, NLP, and Data Visualization. My goal is to make data science engaging an... Read Full Bio

Comments