Java - Constructor & Constructor Overloading

1.Constructor in Java:

A constructor is a special member of a class that is used to initialize objects.

A constructor is automatically called when an object is created using the new keyword.

Important Features of Constructors

The constructor name must be the same as the class name.
A constructor does not have a return type, not even void.
It is called automatically when an object is created.
Constructors can have parameters.
Constructors can be overloaded.

Example:

`class Student {

Student() { System.out.println("Constructor Called!"); } public static void main(String[] args) { Student s1 = new Student(); }

Output:

Constructor Called!

Explanation:

Student is the class name.
Student() is the constructor.
new Student() creates an object.
The constructor is automatically executed when the object is created.

2.Types of Constructors in Java

Java constructors are commonly explained using two categories:

1.Default Constructor

If we do not write any constructor in a class, the Java compiler provides a default constructor.

It initializes instance variables with their default values.

Example:

`class Student {
int age;
String name;

public static void main(String[] args) { Student s1 = new Student(); System.out.println(s1.age); System.out.println(s1.name); }

Output:

0
null

Here, Java provides a default constructor because we did not define any constructor.

Note: If we write our own constructor, the compiler does not automatically provide a default constructor.

2.No-Argument Constructor

A no-argument constructor is a constructor written by the programmer that does not accept any parameters.

Example:

`class Student {

Student() { System.out.println("Welcome to Java!"); } public static void main(String[] args) { Student s1 = new Student(); }

Output:

Welcome to Java!

Here, Student() is a programmer-defined no-argument constructor.

3.Parameterized Constructor

A parameterized constructor accepts arguments to initialize object values.

Example:

`class Student {
String name;
int age;

Student(String n, int a) { name = n; age = a; } void display() { System.out.println(name); System.out.println(age); } public static void main(String[] args) { Student s1 = new Student("Gowtham", 20); s1.display(); }

Output:

Gowtham
20

Explanation:

Student(String n, int a) is a parameterized constructor.
name = n assigns the name.
age = a assigns the age.
new Student("Gowtham", 20) creates an object and passes values to the constructor.

3.Constructor Overloading in Java:

Constructor overloading means creating multiple constructors in the same class with different parameter lists.

It allows us to initialize objects in different ways.

Example:

`class Student {

String name; int age; Student() { name = "Unknown"; age = 0; } Student(String n) { name = n; age = 18; } Student(String n, int a) { name = n; age = a; } void display() { System.out.println(name + " " + age); } public static void main(String[] args) { Student s1 = new Student(); Student s2 = new Student("Gowtham"); Student s3 = new Student("Arun", 21); s1.display(); s2.display(); s3.display(); }

Output:

Unknown 0
Gowtham 18
Arun 21

Explanation:

In this example, we have created three constructors:
Student() – No-argument constructor.
Student(String n) – Constructor with one parameter.
Student(String n, int a) – Constructor with two parameters.
Java automatically selects the matching constructor based on the arguments passed when creating an object.