Scribd
Upload
184 views9 pages

Class7 (Constructor in Java)

Constructors in Java are special methods that initialize objects. There are two types of constructors: default constructors that take no parameters, and parameterized constructors that receive parameters. Constructor overloading allows creating constructors with the same name but different parameters. A copy constructor initializes a new object using an existing object of the same class. Constructors differ from methods in that they are called implicitly during object creation, have no return type, and are not inherited by subclasses.

Uploaded by

Doton Dutta
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
184 views9 pages

Class7 (Constructor in Java)

Constructors in Java are special methods that initialize objects. There are two types of constructors: default constructors that take no parameters, and parameterized constructors that receive parameters. Constructor overloading allows creating constructors with the same name but different parameters. A copy constructor initializes a new object using an existing object of the same class. Constructors differ from methods in that they are called implicitly during object creation, have no return type, and are not inherited by subclasses.

Uploaded by

Doton Dutta
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 9

Constructors in Java

Key Points:-
1. Definition of constructor?
2. Types of Constructor
3. Constructor overloading
4. Difference between constructor and Method

A constructor is a special method that is used to initialize an


object.Every class has a constructor,if we don't explicitly declare a
constructor for any java class the compiler builds a default constructor
for that class. A constructor does not have any return type.
A constructor has same name as the class in which it resides.
Constructor in Java can not be abstract, static, final or synchronized.
These modifiers are not allowed for constructor.

For example:

Employee emp = new Employee();


Here, Employee() is invoking a default constructor.

Types of Constructor
There are two types of constructors:

• Default Constructor
• Parameterized constructor
• Copy constructor

Each time a new object is created at least one constructor will be


invoked.

Default Constructor
In Java, a constructor is said to be default constructor if it does not have
any parameter. There can be two types of constructor i.e System Define
default constructor or user defines default constructor. If a class does
not contain any constructor then during compilation the system
generates a default constructor which is known as system define default
constructor. If a class contain a constructor with no parameter then it is
known as default constructor

User Define Default Constructor


Example:

Parameterised constructor

A Parameterised constructor receives parameters at the time of


creating an object and initializes the object with the received
values.

If we define only parameterized constructors, then we cannot create an


object with default constructor. This is because compiler will not create
default constructor. You need to create default constructor explicitly.
Example:-

class MyClass {

int x;

// Following is the constructor

MyClass(int i ) {

x = i;

You would call constructor to initialize objects as follows −

public class ConsDemo {

public static void main(String args[]) {

MyClass t1 = new MyClass( 10 );

MyClass t2 = new MyClass( 20 );

System.out.println(t1.x + " " + t2.x);

Copy constructor:

A copy constructor is a constructor that creates a new object using an


existing object of the same class and initializes each instance variable of
newly created object with corresponding instance variables of the existing
object passed as argument. This constructor takes a single argument
whose type is that of the class containing the constructor. A system
provides its own copy constructor if no copy constructor is defined.

class Rectangle
{
int length;
int breadth;
//constructor to initialize length and bredth of rectang of rectangle
Rectangle(int l, int b)
{
length = l;
breadth= b;
}
//copy constructor
Rectangle(Rectangle obj)
{
System.out.println("Copy Constructor Invoked");
length = obj.length;
breadth= obj.breadth;
}
//method to calcuate area of rectangle
int area()
{
return (length * breadth);
}
}
//class to create Rectangle object and calculate area
class CopyConstructor
{
public static void main(String[] args)
{
Rectangle firstRect = new Rectangle(5,6);
Rectangle secondRect= new Rectangle(firstRect);
System.out.println("Area of First Rectangle : "+
firstRect.area());
System .out.println("Area of First Second Rectangle : "+
secondRect.area());
}
}

Output:-
Copy constructor Invoked
Area of First Rectangle :30
Area of First Second Rectangle :30

Example-2

class pnb
{

private int sa;

public pnb()

{}

public pnb(int x)

sa=x;

public pnb(pnb x)

this.sa=x.sa;

public void display()

System.out.println("Saving Account = "+sa);

class CopyDemo1

public static void main(String as[])

pnb obj = new pnb(2000);

pnb obj1 = new pnb(obj);

pnb obj2 = new pnb();


System.out.println("object ");

obj.display();

System.out.println("object 1");

obj1.display();

System.out.println("object 2");

obj2.display();

System.out.println("System provide its own copy constructor ==>


object 2");

obj2=obj;

obj2.display();

Constructor overloading:-

The process of using a number of constructors with the same


name but different types of parameters is known as Constructor
overloading. Sometimes there is a need of initializing an object in
different ways.

Example:-

// Java program to illustrate


// Constructor Overloading
class Box
{
double width, height, depth;

// constructor used when all dimensions


// specified
Box(double w, double h, double d)
{
width = w;
height = h;
depth = d;
}

// constructor used when no dimensions


// specified
Box()
{
width = height = depth = 0;
}

// constructor used when cube is created


Box(double len)
{
width = height = depth = len;
}

// compute and return volume


double volume()
{
return width * height * depth;
}
}

// Driver code
public class Test
{
public static void main(String args[])
{
// create boxes using the various
// constructors
Box mybox1 = new Box(10, 20, 15);
Box mybox2 = new Box();
Box mycube = new Box(7);

double vol;

// get volume of first box


vol = mybox1.volume();
System.out.println(" Volume of mybox1 is " + vol);

// get volume of second box


vol = mybox2.volume();
System.out.println(" Volume of mybox2 is " + vol);

// get volume of cube


vol = mycube.volume();
System.out.println(" Volume of mycube is " + vol);
}
}
Output:
Volume of mybox1 is 3000.0
Volume of mybox2 is 0.0
Volume of mycube is 343.0

Difference between constructor and method.

Constructor Method

It is a group of statements that can


It is a block of code that
be called at any point in the program
initializes a newly created
using its name to perform a specific
object.
task.

It has the same name as It should have a different name than


class name. class name.

It needs a valid return type if it


It has no return type
returns a value otherwise void

It is called implicitly at the It is called explicitly by the


time of object creation programmer by making a method call

If a constructor is not
present, a default In case of a method, no default
constructor is provided by method is provided.
Java

It is not inherited by It may or may not be inherited


subclasses. depending upon its access specifier.

You might also like