Constructors
❖ A constructor in Java is similar to a method that is invoked when
an object of the class is created.
❖ Unlike Java methods, a constructor has the same name as that of
the class and does not have any return type.
For example,
class Test {
Test() {
// constructor body
}
}
Here,
❖ Test() is a constructor. It has the same name as that of the class
and doesn't have a return type.
❖
Example:
class Cons {
private String name;
// constructor
Cons() {
[Link]("Constructor Called:");
name = "Prajesh";
}
public static void main(String[] args) {
// constructor is invoked while creating an object of the Cons class
Cons obj = new Cons();
[Link]("The name is " + [Link]);
}
}
Output:
Constructor Called:
The name is Prajesh
Types of Constructor
In Java, constructors can be divided into three types:
1. No-Arg Constructor
2. Parameterized Constructor
3. Default Constructor
1. No-Arg Constructors:
❖ Similar to methods, a Java constructor may or may not have any
parameters (arguments).
❖ If a constructor does not accept any parameters, it is known as a
no-argument constructor.
For example,
private Constructor()
{
// body of the constructor
}
For example: Java Private No-arg Constructor
class Main {
int i;
// constructor with no parameter
private Main() {
i = 5;
[Link]("Constructor is called");
}
public static void main(String[] args) {
// calling the constructor without any parameter
Main obj = new Main();
[Link]("Value of i: " + obj.i);
}
}
Output:
Constructor is called
Value of i: 5
Example: Java Public no-arg Constructors
class Company {
String name;
// public constructor
public Company() {
name = "Prabha";
}
}
class Main {
public static void main(String[] args) {
// object is created in another class
Company obj = new Company();
[Link]("Company name = " + [Link]);
}
}
Output:
Company name = Prabha
2. Parameterized Constructor:
❖ A Java constructor can also accept one or more parameters. Such
constructors are known as parameterized constructors
(constructors with parameters).
Example: Parameterized Constructor
class Main {
String languages;
// constructor accepting single value
Main(String lang) {
languages = lang;
[Link](languages + " Programming Language");
}
public static void main(String[] args) {
// call constructor by passing a single value
Main obj1 = new Main("Java");
Main obj2 = new Main("Python");
Main obj3 = new Main("C");
}
}
Output:
Java Programming Language
Python Programming Language
C Programming Language
In the above example,
❖ We have created a constructor named Main() .
❖ Here, the constructor takes a single parameter. Notice the
expression:
Main obj1 = new Main("Java");
❖ Here, we are passing the single value to the constructor.
❖ Based on the argument passed, the language variable is initialized
inside the constructor.
3. Default Constructor:
❖ If we do not create any constructor, the Java compiler
automatically creates a no-arg constructor during the
execution of the program. This constructor is called the default
constructor.
Example: Default Constructor
class Main {
int a;
boolean b;
public static void main(String[] args) {
// calls default constructor
Main obj = new Main();
[Link]("Default Value:");
[Link]("a = " + obj.a);
[Link]("b = " + obj.b);
}
}
Output:
Default Value:
a = 0
b = false
❖ Here, we haven't created any constructors. Hence, the Java compiler
automatically creates the default constructor.
❖ The default constructor initializes any uninitialized instance variables
with default values.
Type Default Value
boolean false
byte 0
short 0
int 0
long 0L
char \u0000
float 0.0f
double 0.0d
object Reference null
Important Notes on Java Constructors
❖ Constructors are invoked implicitly when you instantiate objects.
❖ The two rules for creating a constructor are:
1. The name of the constructor should be the same as the class.
2. A Java constructor must not have a return type.
❖ If a class doesn't have a constructor, the Java compiler automatically
creates a default constructor during run-time.
❖ The default constructor initializes instance variables with default values.
For example, the int variable will be initialized to 0
❖ Constructortypes:
1. No-Arg Constructor - a constructor that does not accept any arguments
2. Parameterized constructor - a constructor that accepts arguments
3. Default Constructor - a constructor that is automatically created by the Java
compiler if it is not explicitly defined.
❖ A constructor cannot be abstract or static or final.
❖ A constructor can be overloaded but can not be overridden.
Constructors Overloading in Java:
❖ Similar to Java method overloading, we can also create two or more
constructors with different parameters. This is called constructor overloading.
Example: Constructor Overloading
class Main {
String language;
// constructor with no parameter
Main() {
[Link] = "Java";
}
// constructor with a single parameter
Main(String language) {
[Link] = language;
}
public void getName() {
[Link]("Programming Language: " + [Link]);
}
public static void main(String[] args) {
// call constructor with no parameter
Main obj1 = new Main();
// call constructor with a single parameter
Main obj2 = new Main("Python");
[Link]();
[Link]();
}
}
Output:
Programming Language: Java
Programming Language: Python
