Scribd
Upload
159 views6 pages

Java Constructor Rules and Examples

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
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
159 views6 pages

Java Constructor Rules and Examples

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
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

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()
{
[Link]("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()
{[Link](id+" "+name);}

public static void main(String args[]){


//creating objects
Student3 s1=new Student3();
Student3 s2=new Student3();
//displaying values of the object
[Link]();
[Link]();
}

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()
{[Link](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
[Link]();
[Link]();
}
}

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()
{[Link](id+" "+name+" "+age);}

public static void main(String args[]){


Student5 s1 = new Student5(111,"Rama");
Student5 s2 = new Student5(222,"Amit",25);
[Link]();
[Link]();
}
}

Output:
111 Rama 0
222 Amit 25

Common questions

Powered by AI

When no constructors are explicitly defined in a Java class, the Java compiler automatically provides a default constructor. This default constructor is a no-argument constructor that initializes the object with default values for each field (e.g., 0 for numeric fields, null for objects, etc.).

The Bike class demonstrates the functionality of a default constructor by creating an instance of the Bike class, which triggers the default constructor. In this example, upon instantiation with `new Bike1()`, the default constructor is called, which prints "Bike is created," illustrating how a default constructor initializes an object without requiring parameters .

Constructor overloading is significant for user-defined classes in Java as it increases the flexibility and readability of code by allowing different ways to instantiate objects with varying levels of detail. This helps accommodate various initialization scenarios without redundancy, streamlining the process of object creation and potentially reducing errors associated with improper initialization .

Constructors in Java cannot be abstract or static because constructors are designed to initialize a new object of a class, which requires an instance context. An abstract or static constructor would contradict the fundamental purpose of a constructor — to create and initialize instances. Abstract constructs imply incomplete implementation, while static implies it belongs to the class level, not instances .

A Java constructor does not have an explicit return type because its primary role is to initialize an instance of an object, not to return data like traditional methods. This implicit mechanism ensures that constructors are solely dedicated to setting up initial state and avoid any operational or logical overhead related to processing or output typical of methods with return types .

In Java, there are two main types of constructors: the default constructor (no-arg constructor) and the parameterized constructor. The default constructor has no parameters and is used to set default values to objects when instantiated without any arguments. Meanwhile, a parameterized constructor has one or more parameters and is used to initialize objects with specific values provided at the time of creation .

Constructor overloading in Java is a technique where a class can have multiple constructors each with different parameter lists. These constructors are differentiated by the number and types of their parameters. For example, in a Student class, one constructor might initialize only the student's ID and name, while another might also include age. This allows flexibility in object initialization based on available data . Example: A Student class might have one constructor with ID and name, and another with ID, name, and age, providing tailored object initialization .

The rules for naming constructors in Java are: the constructor name must be the same as the class name, and it must have no explicit return type. These rules are important because they ensure that constructors are distinct from methods, allowing the Java compiler to recognize the code block meant for object initialization immediately when an object is instantiated .

A parameterized constructor is preferred when there is a need to initialize objects with specific, non-default values. For instance, in a scenario where each object of a class represents a unique entity with known attributes: creating a Student record system where each 'Student' object needs to capture distinct attributes such as ID, name, and age at the time of object creation. Using a parameterized constructor ensures that all necessary properties are set at the instance's initialization .

Java constructors differ from regular methods in that constructors do not have return types and are invoked automatically when an object is created. Methods, in contrast, require specific calls and have defined return types. Constructors are meant for object initialization, while methods define behaviors of an object after it's created .

You might also like