Constructor
Definition
A constructor is a special member method of a class that is automatically
called while creating an object to initialize its elements(data member /
attributes).
It has the same name as the class name.
It has no return type,not even void.
Constructors should be declared in the public section of the Class.
The constructor is called (invoked) automatically when an object of a class
is created.
Rule: If there is no constructor in a class, compiler automatically creates a default constructor.
Rules for creating Java 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
Need for constructor:
Create instance of class.(means creating an object)
It can be used to set initial values for object attributes(variables) of a
class .
class Test
{
public Test() // Constructor
// body of constructor
Invoking a constructor
Constructors are invoked automatically when we create objects for the class.
Syntax:
<class name><>obj name> = new <constructor / class name>;
Example:
Test obj= new Test();
Here, Test() will invoke the default constructor.
Why should we define a constructor public.
By defining public , the objects can be created in any method.
The constructor can be called outside the class(by creating object)
Hence the access specifier of a constructor is always public.
Characteristics /Features
Used to initialize the data members.No arithmatic or logical operations are
performed in a constructor.
Constructors name must be similar to that of the class name inside which it
resides.This allows the constructors to be invoked automatically on object
creation.)
Constructors are automatically(implicitly) called when an object is created.
Item ob=new item();
Constructors cannot be private.
A constructor cannot be abstract, static, final.
A constructor can be overloaded.
Constructors cannot return a value.
Constructors do not have a return type; not even void.
Reason : Constructors are used to initialize the data members.No arithmatic
or logical operations are performed in a constructor.Hence return from
constructor is not required.
An abstract class can have the constructor.
Constructors cannot be inherited; but can be accessed by a subclass
(Reason: instance variables and methods of a class are known as members of a
class. Constructors are not members.For this reason, constructors cannot be
inherited; but can be accessed by a subclass
Types of constructors
a) Parameterised constructor
b) Non Parameterised constructor
c) Default constructor
d) Copy constructor
Parameterised constructor
A parameterised constructor is a member method with same name as the class
name which is used to initialize the instance variables with the help of parametric
values (given as arguments) , passed at the time of creating an object.
Class student
int regno;
String name;
char section;
float average;
student(int x, String y, char z, float f) // Parameterised constructor
regno =x;
name = y;
section=z;
average=f;
}
Void display ()
System.out.println(x);
System.out.println(y);
System.out.println(z);
System.out.println(f);
Public static void main(String args[])
Student stu = new student(5,”Sheela”,’A’,23.4); // parameterised constructor
Stu.display();
}}
// if user did not create object, we have to run the
Program differently to understand that compiler creates its own object( Page 397)
Non Parameterised constructor
A constructor which initialises the instance variables with definite values readily
available within it is called as non – parameterised constructor.
Class student
{
int regno;
String name;
student() // Non – parameterised constructor
regno =10;
name = “Sheela”;
Void display ()
System.out.println(x);
System.out.println(y);
System.out.println(z);
System.out.println(f);
Public static void main(String args[])
Student stu = new student(); // calling non parameterised constructor
Stu.display();
}}
Default constructor:
The constructor which is used to initialise the data members with default
initial values(0,null,empty values) is called as default constructor.
We need not explicitly define a default constructor as the compiler will
supply a default constructor.
Class student
int regno;
String name;
char section;
float marks;
Void display ()
System.out.println(regno);
System.out.println(name);
System.out.println(section);
System.out.println(marks);
Public static void main(String args[])
Student stu = new student(); // calling default constructor
Stu.display();
}}
Output:
Null
(empty )
0.0
Note :
Defining a constructor with arguments hides the default constructor.
With Parameterised constructor for a class , one must provide initial values
as arguments , otherwise compiler will report an error .
Copy constructor
A constructor that is used to initialize the instance variables of an object by
copying the initial values of the instance variables from another object.
2 Types
a) Direct entry copy constructor
b) Copy constructor by passing object.
Direct entry copy constructor
The initial values of an object is copied by assigning it to another object .
Example:
class copycon
{
int a; // instance variable
copycon(int x) // Parameterised constructor
a=x;
public static void main (String srgs[])
Copycon ob=new copycon(5); // paramerised constructor call
Copycon ob1=ob; // Direct entry copy constructor
Copy constructor by passing object.
Here object is passed to the constructor and the instance variables of current object
are initialised by copying the values from object passed to the constructor.
Example:
class copycon
int a; // instance variable
copycon(int x) // Parameterised constructor
{
a=x;
copycon(copycon ob) //copy constructor by passing object
a=ob.a;
public static void main (String srgs[])
copycon ob=new copycon(5); // paramerised constructor call
copycon ob1=ob; // Direct entry copy constructor
copycon ob1=new copycon(ob) // Copy constructor by passing object
use of constructors
Constructor overloading.
It is the process of using a number of constructors with the same name but
having different parameter list.
The compiler differentiates the constructor by taking into account the
number of parameters in the list and their type.
If a class contains more than one constructors then they are overloading
constructor.
Example:
class copycon
int a; // instance variable
copycon( ) // Non – parameterised constructor
a=10;
copycon(int x) // Parameterised constructor
a=x;
copycon(copycon ob) //Copy constructor by passing object
a=ob.a;
public static void main (String srgs[])
copycon ob=new copycon(); // Non - paramerised constructor call
copycon ob=new copycon(5); // paramerised constructor call
copycon ob1=ob; // Direct entry copy constructor
copycon ob1=new copycon(ob) // Copy constructor by passing object
Difference between constructor and method.
Page 401
