A constructor in Java is a unique method used in object-oriented programming to initialize objects of a class. It is automatically invoked when an object is created using the new keyword and has the same name as the class.

1. JAVA ROADMAP
Constructors In Java – Unveiling
Object Creation
A constructor in Java is a unique method used in object-oriented programming to
initialize objects of a class. It is automatically invoked when an object is created
using the new keyword and has the same name as the class.
The main goal of a constructor is to make sure that an object (previously discussed)
is correctly initialized and in a valid state before it is used. A valid state denotes that
an object is in good and useable condition. In other words, it signifies that all of the
crucial information included within the object has been properly configured.
Syntax:
[access modifier] ClassName([parameters]) {
// Constructor body
// Initialization code and other statements
}
In the above syntax:
● [access modifier] specifies the visibility of the constructor, such as public,
private, or protected. If no access modifier is specified, it defaults to
package-private.

2. ● ClassName is the name of the class to which the constructor belongs. It
must match the class name exactly.
● parameters represent any input values that the constructor may accept.
Multiple parameters are separated by commas.
● The constructor body contains the initialization code and other statements
that execute when the constructor is called.
Let’s take the example of a Car object. For the Car object to be in a valid state, it
means that its characteristics, like the make (brand), model, and manufacturing year,
have been set to meaningful values that make sense for a car. If any of these
characteristics are missing or have incorrect values, the Car object would not be in a
valid state.
Example:
public class Car {
private String make;
private String model;
private int year;
// Constructor with parameters
public Car(String make, String model, int year) {
this.make = make;
this.model = model;
this.year = year;
}
// Default constructor (no parameters)
public Car() {
this.make = "Unknown";
this.model = "Unknown";
this.year = 0;
}
// Other methods and members of the Car class...
}
We have a Car class with two constructors in this example. The first constructor
takes three inputs (make, model, and year) and sets the member variables
accordingly. The second constructor is a default constructor that assigns default
values to the memberJava variables.
Now, let’s create Car objects using these constructors:
public class Main {

3. public static void main(String[] args) {
Car car1 = new Car("Toyota", "Corolla", 2021);
// Constructor with parameters is called, creating a Car object with the provided values
Car car2 = new Car();
// Default constructor is called, creating a Car object with default values
// Accessing the member variables
System.out.println("Car 1: " + car1.make + " " + car1.model + " " + car1.year);
System.out.println("Car 2: " + car2.make + " " + car2.model + " " + car2.year);
}
}
Output:
Car 1: Toyota Corolla 2021
Car 2: Unknown Unknown 0
In the main method, we create two Car objects: car1 and car2. The first object is
created using the constructor with parameters, while the second object is created
using the default constructor.
● car1 is created using the constructor with parameters. Its make is set to
“Toyota”, model to “Corolla”, and year to 2021.
● car2 is created using the default constructor. Since no specific values are
passed, its make and model variables are set to “Unknown”, and the year
is set to 0 (default values).
Then, we use System.out.println to print the values of make, model, and year for
both car1 and car2. The output shows the values assigned to the member variables
for each object.
Now you must be wondering that the same thing can be done using methods inside
the class Car, and… you are right. You can do the same thing in the following way:
public class Car {
private String make;
private String model;
private int year;
// Method to set the car details
public void setCarDetails(String make, String model, int year) {
this.make = make;
this.model = model;
this.year = year;

4. }
// Method to display car information
public void displayCarInfo() {
System.out.println(make + model + year);
}
// Other methods and members of the Car class...
}
public class Main {
public static void main(String[] args) {
Car car1 = new Car();
car1.setCarDetails("Toyota", "Corolla", 2021);
Car car2 = new Car();
car2.setCarDetails("Unknown", "Unknown", 0);
System.out.print("Car 1: ");
car1.displayCarInfo();
System.out.println();
System.out.print("Car 2: ");
car2.displayCarInfo();
}
}
Output:
Car 1: Toyota Corolla 2021
Car 2: Unknown Unknown 0
In this example, we have a Car class with two methods: setCarDetails and
displayCarInfo. The setCarDetails method takes the car details as parameters
(make, model, and year) and sets the corresponding member variables accordingly.
The displayCarInfo method is responsible for displaying the car information by
printing the values of the member variables.
In the main method, we create two Car objects: car1 and car2. After creating the
objects, we call the setCarDetails method on each object to set the car details. Then,
we call the displayCarInfo method on each object to print the car information.
Question – Why do we need constructors, if we can do
the same thing using methods?

5. Constructors in Java are crucial for object initialization. Unlike methods that perform
actions on objects, constructors focus on setting up objects from their creation. They
ensure objects start in a valid state, provide standardised initialization, enforce
encapsulation, and support inheritance. Constructors simplify the initialization
process, allow for default values, and enhance code readability. In short,
constructors are essential for proper object setup and initialization in Java.
Difference Between Constructor And Methods In Java
Constructors Methods
Used for object initialization Used for performing actions/calculations
Automatically called when an
object is created
Explicitly called by their name
No return type (not even void) Have a return type, e.g., int, String, void
Same name as the class Have their own distinct names
Can be overloaded with different
parameter lists
Can also be overloaded, but with different
names
Can provide default values for
member variables
Do not provide default values
Focus on setting up the object’s
initial state
Focus on performing specific operations on
the object

6. Enforce encapsulation by
initializing private member
variables
Can access and modify private variables, but
not responsible for object initialization
Inherited from superclass to
subclass
Inherited like any other method, with no
special inheritance behaviour
Types Of Constructor In Java
In Java, there are three types of constructors: default constructor, parameterized
constructor, and copy constructor.
● Default Constructor: Initializes member variables with default values. No
parameters. It sets the object’s initial state to default values.
● Parameterized Constructor: Accepts parameters to initialize member
variables with specific values. This allows objects to be created with
different initial states based on the values passed to the constructor.
● Copy Constructor: Creates a new object by copying values from another
object of the same class. You can establish separate instances with
identical data by copying values from one object to another, allowing you to
operate with them separately.
Let’s deep dive into every type of constructor one by one.
Default constructor
In Java, a Default Constructor is a special constructor that is automatically provided
by the Java compiler if no other constructor is explicitly defined in a class. It is called
the “default” constructor because it is used when no specific arguments are provided
during object creation.
The Default Constructor’s purpose is to assign default values to an object’s member
variables. These default values are determined by the variable’s data type. Numeric
types, for example, are set to 0, boolean variables are set to false, and reference
types (such as objects or strings) are set to null.
Example:
public class Person {
private String name;

7. private int age;
// Default Constructor
public Person() {
name = "Unknown";
age = 0;
}
// Other members and methods...
}
In the example, we have a Person class with a default constructor. The default
constructor is defined without any parameters. It initializes the name variable to
“Unknown” and the age variable to 0. These are the default values assigned to the
member variables when a new Person object is created without explicitly providing
any arguments.
The Default Constructor allows you to create objects of the Person class without
specifying any values. For instance, if you create a Person object using Person
person = new Person();, the name will be “Unknown” and the age will be 0.
VISIT
BLOG.GEEKSTER.IN
FOR THE REMAINING