1. Tipuri de constructori
   1. Constructor implicit
   2. Constructor parametrizat
2. Supraîncărcarea constructorului
3. Constructorul returnează vreo valoare?
4. Copierea valorilor unui obiect în altul
5. Constructorul efectuează alte sarcini în loc de inițializare

În Java , un constructor este un bloc de coduri similar cu metoda. Se numește atunci când o instanță a clasă este creat. În momentul apelării constructorului, memoria pentru obiect este alocată în memorie.

Este un tip special de metodă care este folosită pentru a inițializa obiectul.

De fiecare dată când un obiect este creat folosind cuvântul cheie new(), cel puțin un constructor este apelat.

Apelează un constructor implicit dacă nu există niciun constructor disponibil în clasă. În acest caz, compilatorul Java oferă implicit un constructor implicit.

Există două tipuri de constructori în Java: constructor no-arg și constructor parametrizat.

Notă: Se numește constructor deoarece construiește valorile în momentul creării obiectului. Nu este necesar să scrieți un constructor pentru o clasă. Se datorează faptului că compilatorul java creează un constructor implicit dacă clasa ta nu are niciunul.

Reguli pentru crearea constructorului Java

Există două reguli definite pentru constructor.

metoda substring în java

1. Numele constructorului trebuie să fie același cu numele clasei sale
2. Un constructor nu trebuie să aibă un tip de returnare explicit
3. Un constructor Java nu poate fi abstract, static, final și sincronizat

Notă: putem folosi modificatori de acces în timp ce se declară un constructor. Acesta controlează crearea obiectului. Cu alte cuvinte, putem avea un constructor privat, protejat, public sau implicit în Java.

Tipuri de constructori Java

Există două tipuri de constructori în Java:

1. Constructor implicit (constructor fără argument)
2. Constructor parametrizat

Constructor implicit Java

Un constructor se numește „Constructor implicit” atunci când nu are niciun parametru.

Sintaxa constructorului implicit:

 (){} 

Exemplu de constructor implicit

 //Java Program to create and call a default constructor 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(); } } 

Ieșire:

 Bike is created 

Regulă: Dacă nu există niciun constructor într-o clasă, compilatorul creează automat un constructor implicit.

Î) Care este scopul unui constructor implicit?

Constructorul implicit este folosit pentru a furniza obiectului valorile implicite, cum ar fi 0, null etc., în funcție de tip.

Exemplu de constructor implicit care afișează valorile implicite

 //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(); } } 

Ieșire:

 0 null 0 null 

Explicaţie: În clasa de mai sus, nu creați niciun constructor, așa că compilatorul vă oferă un constructor implicit. Aici valorile 0 și nule sunt furnizate de constructorul implicit.

Constructor parametrizat Java

Un constructor care are un anumit număr de parametri se numește constructor parametrizat.

De ce să folosiți constructorul parametrizat?

Constructorul parametrizat este folosit pentru a furniza valori diferite unor obiecte distincte. Cu toate acestea, puteți oferi și aceleași valori.

Exemplu de constructor parametrizat

În acest exemplu, am creat constructorul clasei Student care are doi parametri. Putem avea orice număr de parametri în 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(){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(); } } 

Ieșire:

 111 Karan 222 Aryan 

Supraîncărcarea constructorului în Java

În Java, un constructor este la fel ca o metodă, dar fără tip de returnare. De asemenea, poate fi supraîncărcat ca și metodele Java.

Constructor supraîncărcare în Java este o tehnică de a avea mai mult de un constructor cu liste de parametri diferite. Ele sunt aranjate astfel încât fiecare constructor să îndeplinească o sarcină diferită. Ele sunt diferențiate de compilator după numărul de parametri din listă și tipurile acestora.

Exemplu de supraîncărcare a constructorului

 //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(); } } 

Ieșire:

c++ int la șir

 111 Karan 0 222 Aryan 25 

Diferența dintre constructor și metodă în Java

Există multe diferențe între constructori și metode. Ele sunt date mai jos.

Java Copy Constructor

Nu există un constructor de copiere în Java. Cu toate acestea, putem copia valorile de la un obiect la altul ca un constructor de copiere în C++.

Există multe modalități de a copia valorile unui obiect în altul în Java. Sunt:

• Prin constructor
• Prin atribuirea valorilor unui obiect altuia
• Prin metoda clone() a clasei Object

În acest exemplu, vom copia valorile unui obiect în altul folosind constructorul Java.

 //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(); } } 

Ieșire:

 111 Karan 111 Karan 

Copierea valorilor fără constructor

Putem copia valorile unui obiect în altul prin atribuirea valorilor obiectelor unui alt obiect. În acest caz, nu este nevoie să creați constructorul.

 class Student7{ int id; String name; Student7(int i,String n){ id = i; name = n; } Student7(){} void display(){System.out.println(id+' '+name);} public static void main(String args[]){ Student7 s1 = new Student7(111,'Karan'); Student7 s2 = new Student7(); s2.id=s1.id; s2.name=s1.name; s1.display(); s2.display(); } } 

Ieșire:

 111 Karan 111 Karan 

Î) Constructorul returnează vreo valoare?

Da, este instanța actuală a clasei (Nu puteți utiliza tipul de returnare, dar returnează o valoare).

Constructorul poate efectua alte sarcini în loc de inițializare?

Da, cum ar fi crearea de obiecte, pornirea unui fir de execuție, apelarea unei metode etc. Puteți efectua orice operație în constructor așa cum efectuați în metodă.

Există clasă Constructor în Java?

Da.

Care este scopul clasei Constructor?

Java oferă o clasă Constructor care poate fi folosită pentru a obține informațiile interne ale unui constructor din clasă. Se găsește în pachetul java.lang.reflect.