Scribd
Upload
53 views

Constructors in Java: Rules For Creating Java Constructor

Constructors in Java are special methods that are called when an object is created. They initialize the object and are used to set initial values. There are two types of constructors: default (no-arg) constructors that take no parameters, and parameterized constructors that take parameters. Constructors must have the same name as the class and do not have a return type. Constructors can be overloaded to have different parameter lists like methods.

Uploaded by

jit Sahoo
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
53 views

Constructors in Java: Rules For Creating Java Constructor

Constructors in Java are special methods that are called when an object is created. They initialize the object and are used to set initial values. There are two types of constructors: default (no-arg) constructors that take no parameters, and parameterized constructors that take parameters. Constructors must have the same name as the class and do not have a return type. Constructors can be overloaded to have different parameter lists like methods.

Uploaded by

jit Sahoo
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 6

Constructors in Java

In Java, a constructor is a block of codes similar to the method. It is called


when an instance of the class is created. At the time of calling constructor,
memory for the object is allocated in the memory.

It is a special type of method which is used to initialize the object.

Every time an object is created using the new() keyword, at least one
constructor is called.

it calls a default constructor if there is no constructor available in the class.


In such case, Java compiler provides a default constructor by default.

There are two types of constructors in Java:

no-arg constructor, and parameterized constructor.

Note: It is called constructor because it constructs the values at the time of


object creation. It is not necessary to write a constructor for a class. It is
because java compiler creates a default constructor if your class doesn't
have any.

Rules for creating Java constructor


There are two rules defined for the constructor.

1. Constructor name must be the same as its class name


2. A Constructor must have no explicit return type
3. A Java constructor cannot be abstract, static, final, and synchronized

Types of Java constructors

There are two types of constructors in Java:

1. Default constructor (no-arg constructor)


2. Parameterized constructor

Java Default Constructor

A constructor is called "Default Constructor" when it doesn't have any


parameter.

Syntax of default constructor:


<class_name>()
{}
Example of default constructor
In this example, we are creating the no-arg constructor in the Bike class.

It will be invoked at the time of object creation.

//Java Program to create and call a default constructor


class Bike1{
//creating a default constructor
Bike1()
{
System.out.println("Bike is created");}
//main method
public static void main(String args[])
{
//calling a default constructor
Bike1 b=new Bike1();
}
}

Output:

Bike is created

Example of default constructor that displays the default values


class Student3{
int id;
String name;
//method to display the value of id and name
void display()
{System.out.println(id+" "+name);}

public static void main(String args[]){


//creating objects
Student3 s1=new Student3();
Student3 s2=new Student3();
//displaying values of the object
s1.display();
s2.display();
}

Output:

0 null
0 null

Explanation:In the above class,you are not creating any constructor so


compiler provides you a default constructor. Here 0 and null values are
provided by default constructor.

Java Parameterized Constructor

A constructor which has a specific number of parameters is called a


parameterized constructor.

Why use the parameterized constructor?

The parameterized constructor is used to provide different values to


distinct objects. However, you can provide the same values also.
Example of parameterized constructor

In this example, we have created the constructor of Student class that have
two parameters. We can have any number of parameters in the constructor.

//Java Program to demonstrate the use of the parameterized constructor.

class Student4{
int id;
String name;
//creating a parameterized constructor
Student4(int i,String n){
id = i;
name = n;
}
//method to display the values
void display()
{System.out.println(id+" "+name);}

public static void main(String args[]){


//creating objects and passing values
Student4 s1 = new Student4(111,"Rama");
Student4 s2 = new Student4(222,"Amit");
//calling method to display the values of object
s1.display();
s2.display();
}
}

Output:

111 Rama
222 Amit
Constructor Overloading in Java

In Java, a constructor is just like a method but without return type. It can
also be overloaded like Java methods.
Constructor overloading in Java is a technique of having more than one
constructor with different parameter lists. They are arranged in a way that
each constructor performs a different task. They are differentiated by the
compiler by the number of parameters in the list and their types.

Example of Constructor Overloading


//Java program to overload constructors
class Student5{
int id;
String name;
int age;
//creating two arg constructor
Student5(int i,String n){
id = i;
name = n;
}
//creating three arg constructor
Student5(int i,String n,int a)
{
id = i;
name = n;
age=a;
}
void display()
{System.out.println(id+" "+name+" "+age);}

public static void main(String args[]){


Student5 s1 = new Student5(111,"Rama");
Student5 s2 = new Student5(222,"Amit",25);
s1.display();
s2.display();
}
}

Output:
111 Rama 0
222 Amit 25

You might also like