Scribd
Upload
2 views

Java Class 5

In Java, a constructor is a special method used to initialize objects, called when an instance of a class is created. There are two types of constructors: default (no-arg) and parameterized, with rules that include having the same name as the class and no explicit return type. Constructor overloading is possible, allowing multiple constructors with different parameter lists, and constructors differ from methods in several key aspects, such as return type and invocation method.

Uploaded by

Candy Man
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
2 views

Java Class 5

In Java, a constructor is a special method used to initialize objects, called when an instance of a class is created. There are two types of constructors: default (no-arg) and parameterized, with rules that include having the same name as the class and no explicit return type. Constructor overloading is possible, allowing multiple constructors with different parameter lists, and constructors differ from methods in several key aspects, such as return type and invocation method.

Uploaded by

Candy Man
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 13

Constructor

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.
Rules for creating Java constructor

There are two rules defined for the constructor.

 Constructor name must be the same as its class name

 A Constructor must have no explicit return type

 A Java constructor cannot be abstract, static, final, and

synchronized

Types of Java constructors


There are two types of constructors in Java:

Default constructor (no-arg constructor)

Parameterized constructor
Java Default Constructor

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


any parameter.

Syntax of default constructor:

<class_name>()
{
}
//Java Program to create and call a default construc
tor
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();
}
}
Rule: If there is no constructor in a class, compiler automatically creates
a default constructor.
Q) What is the purpose of a default constructor?

The default constructor is used to provide the default values to the


object like 0, null, etc., depending on the type.

//Let us see another example of default constructor


//which 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();
}
}
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.
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,"Karan");
Student4 s2 = new Student4(222,"Aryan");
//calling method to display the values of object
s1.display();
s2.display();
}
}
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.
//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,"Karan");
Student5 s2 = new Student5(222,"Aryan",25);
s1.display();
s2.display();
}
}
Difference between constructor and method in Java
There are many differences between constructors and methods. They are given
below.

Java Constructor Java Method


A constructor is used to initialize the state A method is used to expose the behavior
of an object. of an object.
A constructor must not have a return type. A method must have a return type.

The constructor is invoked implicitly. The method is invoked explicitly.

The Java compiler provides a default The method is not provided by the
constructor if you don't have any compiler in any case.
constructor in a class.

The constructor name must be same as The method name may or may not be
the class name. same as the class name.
Java Copy Constructor
There is no copy constructor in Java. However, we can copy the
values from one object to another like copy constructor in C++.

By assigning the values of one object into another


//Java program to initialize the values from one object to another object.
class Student6{
int id;
String name;
//constructor to initialize integer and string
Student6(int i,String n){
id = i;
name = n;
}
//constructor to initialize another object
Student6(Student6 s){
id = s.id;
name =s.name;
}
void display(){System.out.println(id+" "+name);}

public static void main(String args[]){


Student6 s1 = new Student6(111,"Karan");
Student6 s2 = new Student6(s1);
s1.display();
s2.display();
}
}

You might also like