Constructor in Java with Example
Java Constructor The constructor is used for object initialization. It's a block of code that initializes a newly created object. It contains a collection of statements that are executed at the time of object creation. The constructor is not mandatory for a programmer to write it for a class, but for the ease of program and security purpose, we make constructors. If the user does not define any constructor for a class, compiler initializes member variables to its default values.
Rules for creating a Java constructor
Some rules for creating a Java constructor are as follows- A constructor name should be same as the class name.
- A constructor should not return a value (not even void).
- A constructor should not be abstract, final, static, and synchronize.
- A constructor can use the access modifier in constructor declaration to control its access.
publicclassDemo{ //This is the constructor Demo() { } .. }After a Constructor is created, now a question arises that how it works? The answer is when an object is created using new keyword; then a constructor is invoked for initializing the newly created object.
Demo obj= new Demo()Here the new keyword creates the object of the class Demo and invokes the constructor to initialize the object of Demo class. Example
publicclass Hello { String name; //Constructor Hello(){ this.name = "Java Constructor."; } publicstaticvoid main(String[] args) { Hello obj = newHello(); System.out.println(obj.name); } }Output
Java Constructor.
Types of constructors
There are three types of constructors.- Default constructor
- Parameterized constructor
- No-argument constructor
Parameterized constructor
A constructor that can have arguments or parameters is known as parameterized constructor. These parameters are used to initialize attributes. Example1publicclassExDemo{ intx; publicExDemo(inty) { x = y; } publicstaticvoid main(String[] args) { ExDemoObj = newExDemo(5); System.out.println(Obj.x); }}Output
5You can pass more than one parameters in a constructor. Example2
publicclass Employee { intempId; String empName; //parameterized constructor with two parameters Employee(intid, String name){ this.empId = id; this.empName = name; } void detail(){ System.out.println("Name: "+empName+" id: "+empId); } publicstaticvoid main(String args[]){ Employee e1 = newEmployee(12527,"Vijay"); Employee e2 = newEmployee(12528,"Vikram"); e1.detail(); e2.detail(); } }Output
Name: Vijay id: 12527 Name: Vikram id: 12528No-argument constructor A constructor that has no parameter or arguments is called as No-argument constructor. Signature of No-argument constructor is the same as default constructor; however, the body can have any code, unlike default constructor. If you write a constructor with arguments or no-arguments, then the compiler does not create a default constructor. Example
class ExDemo1 { public ExDemo1() { System.out.println("In No-arg constructor"); } publicstaticvoid main(String args[]) { new ExDemo1(); } }Output
In No-arg constructor
Constructor overloading
Constructors allow overloading as methods do. Constructor overloading is a technique in Java that allows a class can have any number of the constructor, but each constructor should be different in the parameter list. Compiler differentiates constructors based on the number of parameters and their types. Let's have a look at the below example Exampleclass Student { intRoll_no; String SName; doubleMarks; Student(intR,StringN,doubleM) //Constructor 1 { Roll_no = R; SName = N; Marks = M; } Student(String N,doubleM,intR) //Constructor 2 { Roll_no = R; SName = N; Marks = M; } void Display() { System.out.print("\n\t" + Roll_no+"\t" + SName+"\t" + Marks); } publicstaticvoid main(String[] args) { Student S1 = newStudent(1,"akash mishra",85.57); // Statement 2 Student S2 = newStudent(2,"vaibhav Saxena",87.65); // Statement 1 System.out.print("\n\tRoll_no\tSName\tMarks\n"); S1.Display(); S2.Display(); } }Output
Rollno SName Marks 1 akashmishra 85.57 2 vaibhavSaxena 87.65Constructor chaining Constructor chaining is a technique of calling one constructor from another constructor concerning current object. You can pass the parameters through a bunch of different constructors.You can maintain your initializations from a single location. Constructor chaining can be applied in two ways
- Within same class
- From base class
Constructor chaining within the same class using this()
- this() should always be the first statement of the constructor for constructor chaining.
- Constructors can be in any order for constructor chaining; it is not necessary to put them in order.
- At least one constructor should be without this() keyword.
class ExDemo2 { ExDemo2() { this(11); System.out.println(" Default constructor"); } ExDemo2(intx) { this(10, 12); System.out.println(x); } ExDemo2(intx, inty) { System.out.println(x * y); } publicstaticvoid main(String args[]) { new ExDemo2(); } }Output
120 11 Default constructorConstructor chaining from base class usingsuper()
class ExDemo3 { String name; ExDemo3() { this(""); System.out.println("This is No-argument constructor"); } ExDemo3(String name) { this.name = name; System.out.println("This is parameterized constructor"); } } class Child extends ExDemo3 { // constructor 3 Child() { System.out.println("This is No-argument constructor " + "of child class"); } Child(String name) { super(name); System.out.println("This is parameterized " + "constructor of Child class"); } publicstaticvoid main(String args[]) { Child obj = newChild("ExDemo3"); } }Output
This is parameterized constructor This is parameterized constructor of Child classsuper() should be the first line of the constructor as super class constructor are invoked before the subclass constructor.
Java copy constructor
By default, Java does not support any copy constructor, but we can copy the values from one object to other like a copy constructor. Below is an example of copying values from one object to another object using Java constructor. ExampleclassEmpl{ intid; String name; Empl(inti,Stringn){ id = i; name = n; } Empl(Emple){ id = e.id; name =e.name; } void display(){System.out.println(id+" "+name);} publicstaticvoid main(String args[]){ Emple1 = newEmpl(125,"Raghav"); Emple2 = newEmpl(e1); e1.display(); e2.display(); } }Output
125 Raghav 125 Raghav