Java Constructor

java constructor class

Încercați Instrumentul Nostru Pentru Eliminarea Problemelor

Selectați Sistemul De Operare Alegeți Un Program De Proiecție (Opțional)

Descrie -Ți Problema

Acest tutorial va discuta despre Java Constructor, tipurile și conceptele sale precum supraîncărcarea constructorului și înlănțuirea constructorului cu exemple de cod:

Din tutorialele noastre anterioare, știm că instanța unei clase se numește obiect. Un obiect al unei clase este creat folosind cuvântul cheie „nou”. O metodă specială numită „constructor” se numește atunci când creăm un obiect cu un cuvânt cheie nou sau când obiectul este instanțiat.

Un constructor este definit ca un bloc de cod pentru a inițializa obiectul clasei. Este identică cu metoda, dar nu este o metodă. Cu toate acestea, poate fi denumită „metodă specială” în Java.

=> Verificați aici pentru a vedea A-Z a tutorialelor de instruire Java aici.

Constructori în Java

Ce veți învăța:

Java Constructor
Concluzie
- Lectură recomandată

Constructorul Java este folosit pentru a inițializa obiectul tocmai creat. Un obiect trebuie să aibă unele date înainte de a fi utilizate în program. Prin urmare, folosim constructor astfel încât să putem atribui câteva date inițiale obiectului.

Ca un exemplu simplu, luați în considerare o clasă ABC pentru care trebuie să creăm un obiect. Să creăm un obiect „myObj” pentru clasa ABC folosind un cuvânt cheie nou.

ABC myObj = new ABC ();

Afirmația de mai sus creează un obiect myObj. Când se creează acest obiect, se numește un constructor pentru clasa ABC fără argument (ABC () descrie că nu există argumente pentru constructor). Deoarece nu există argumente furnizate pentru constructorul de mai sus, câmpurile membre ale myObj vor fi inițializate la valorile lor inițiale implicite.

De exemplu,

Tipurile de date numerice precum int sunt setate la 0.
Valoarea variabilă a tipului de date Char este setată la caracterul nul („ 0”).
Referințele sunt setate la nul.

În acest tutorial, vom discuta constructorii în detaliu împreună cu diferiții constructori utilizați în Java.

Cum să creați un constructor în Java

Pentru a crea un constructor în Java, trebuie să respectăm anumite reguli așa cum sunt prezentate mai jos.

Constructorul clasei are același nume cu cel al clasei.
Nu poate exista un constructor care să fie final, abstract, sincronizat sau static. Acest lucru se datorează faptului că Finalul acționează ca un constant, abstract nu poate fi instanțiat. În timp ce sincronizat este utilizat în cazul filetării multiple, iar cuvântul cheie static este utilizat la nivel de clasă.
Putem folosi modificatori de acces cu constructorii.
Un constructor nu poate avea un tip de returnare.

De exemplu,să definim un elev de clasă după cum urmează:

class Student{ String name; int roll_no; }

Putem crea obiecte din clasa de mai sus folosind noul cuvânt cheie. În timp ce obiectul este creat, putem inițializa variabilele cu doi membri ai acestei clase oferind un constructor. Rețineți că, chiar dacă nu furnizăm un constructor și doar executăm instrucțiunea de mai jos,

Student student = student nou ();

Totuși, Java va executa un constructor implicit care va inițializa variabilele cu doi membri la valorile implicite ale sistemului. Acum, dacă dorim ca valoarea inițială a Student.name să fie „Keith” și roll_no să fie 27, atunci pentru a face acest lucru putem crea următoarea metodă constructor.

Student () { name = 'Keith'; roll_no = 27; }

Când creăm un obiect al clasei elevilor cu enunțul de mai jos

Student student = new Student ();

Apoi valorile inițiale ale variabilelor membre name și roll_no vor fi Keith și respectiv 27.

Acum că este creat un constructor, când va fi chemat?

Un constructor este apelat de fiecare dată când un obiect este creat cu noul cuvânt cheie, ca în cazul de mai sus. După cum sa menționat deja, dacă nu este furnizat niciun constructor, Java oferă un constructor implicit care este apelat atunci când obiectul este creat folosind noul cuvânt cheie.

Exemplu de constructor

Următorul program prezintă un exemplu de constructor în care avem un constructor simplu, fără niciun argument. Acest constructor atribuie pur și simplu valori inițiale variabilelor sale membre.

//class definition class classDemo{ int num1; int num2; //constructor classDemo(){ num1 = 100; num2 = 250; System.out.println('Inside ClassDemo::Constructor'); } public void display(){ System.out.println('num1 = '+ num1); System.out.println('num2 = '+ num2); } } class Main{ public static void main(String args()){ classDemo cd1 = new classDemo(); //create object of ClassDemo cd1.display(); } }

Ieșire:

Exemplu de ieșire demo de clasă

Constructor implicit în Java

Constructorul implicit se mai numește și Constructorul gol . Acest constructor este inserat de compilatorul Java în codul clasei în care nu există un constructor implementat de programator. Constructorul implicit este inserat în timpul compilării și, prin urmare, va apărea numai în fișierul „.class” și nu în codul sursă.

Luați în considerare următoarea clasă Java.

fișier sursă (.java) fișierul clasei (.class)

Clasa Java

În figura de mai sus, prima figură arată codul sursă în care nu am specificat niciun constructor. Deci, atunci când compilăm acest cod și se generează fișierul .class, putem vedea că compilatorul Java a inserat un constructor implicit așa cum se arată în figura alăturată (în culoare albastră).

Notă:

Uneori se folosește un constructor implicit pentru a descrie constructorul no-arg în Java. Dar acești doi termeni sunt diferiți în realitate. No-arg constructor este un tip de constructor în Java specificat de programator. Constructorul implicit este constructorul care este inserat de compilatorul Java.

întrebări de interviu cu seleniu adresate în companii

Prin urmare, deși acești doi termeni sunt folosiți în mod interschimbabil de majoritatea programatorului, este recomandabil să nu confundați acești doi termeni.

Când Java introduce un constructor implicit, dacă programul are variabile, atunci li se atribuie valorile implicite.

Tabelul de mai jos prezintă valorile implicite ale fiecărui tip de date.

Tip	Valoare implicită
char	u0000
Obiect	Referință nulă
boolean	fals
octet	0
mic de statura	0
int	0
lung	0L
pluti	0,0f
dubla	0,0d

Următorul program oferă un exemplu de constructor implicit în Java.

class Main { int num; boolean flag; public static void main(String() args) { // A default constructor is called Main obj = new Main(); System.out.println('num:default value = ' + obj.num); System.out.println('flag:default value = ' + obj.flag); } }

Ieșire:

constructor implicit - ieșire

Tipuri de constructori în Java

Există două tipuri de constructori în Java așa cum se arată mai jos.

Tipuri de constructori în Java

# 1) Constructor fără argumente

Un constructor fără niciun argument se numește no-args sau no-argument constructor. Dacă nu avem un constructor fără niciun argument, atunci compilatorul Java nu creează un constructor implicit pentru clasă.

În general, dacă definim un constructor în clasa noastră, atunci constructorul implicit nu este inserat de compilatorul Java.

Dat mai jos este un exemplu de constructor No-arg

import java.io.*; class DemoClass { int num; String name; // no-args Constructor called when object is created DemoClass() { System.out.println('DemoClass::Constructor called'); System.out.println('Initial member variable values:'); System.out.println('num = ' + num + ' name = ' + name); } } class Main{ public static void main (String() args) { // this will invoke no-args Constructor DemoClass dc1 = new DemoClass(); } }

Ieșire:

No-arg Constructor

În acest program, am oferit un constructor fără argumente. Aici, imprimăm câteva mesaje, inclusiv variabilele membre. Putem vedea în ieșire că mesajele de la constructor sunt afișate indicând faptul că constructorul fără argumente este executat.

# 2) Constructor parametrizat

Un constructor parametrizat are unul sau mai mulți parametri. Putem folosi un constructor parametrizat în cazul în care trebuie să transmitem câteva valori inițiale variabilei membre a clasei.

import java.io.*; class DemoClass { // data members of the class. String name; int id; // parameterized constructor called when object is created DemoClass(String name, int id) { this.name = name; this.id = id; } } class Main { public static void main (String() args) { // this will invoke the parameterized constructor. DemoClass dc1 = new DemoClass('Java', 1); System.out.println('Tutorial Name :' + dc1.name + ', Id :' + dc1.id); } }

Ieșire:

Constructor parametrizat în Java

Aici am furnizat un constructor parametrizat care ia două argumente, adică nume și id.

În corpul constructorului, argumentele sunt atribuite ca valori variabilelor membre nume și respectiv id.

Apoi, în metoda principală, atunci când creăm un obiect nou folosind noul cuvânt cheie, trecem două valori la numele clasei în urma unui nou cuvânt cheie. Acest lucru indică faptul că apelăm la constructorul parametrizat. Când afișăm variabilele membre, putem vedea că acestea au valorile pe care le-am trecut în timp ce creăm obiectul.

Constructori supraîncărcați în Java

Acum se pune întrebarea dacă o clasă poate avea mai mult de un constructor sau este că o clasă poate avea un singur constructor?

Ei bine, putem avea mai mulți constructori într-o clasă. O clasă poate avea la fel de mulți constructori, atâta timp cât sunt supraîncărcați corespunzător.

Deci, ce se înțelege exact prin supraîncărcarea constructorilor?

Supraîncărcarea constructorului este un mecanism care permite unei clase să aibă cât mai mulți constructori, astfel încât toți acești constructori să aibă liste de parametri diferiți, fie că depind de tipurile de parametri sau de ordinea parametrilor.

Programul de mai jos demonstrează supraîncărcarea constructorului.

cel mai bun downloader mp3 pentru Android fără reclame

//class with multiple constructors class DemoClass{ int val1; int val2; //no args Constructor DemoClass(){ val1 = 10; val2 = 20; System.out.println('DemoClass:: No argument Constructor'); } //Overloaded Constructor DemoClass(int num1){ val1 = num1; val2 = num1; System.out.println('DemoClass:: Overloaded Constructor with one argument'); } //Overloaded DemoClass(int num1,int num2){ val1 = num1; val2 = num2; System.out.println('DemoClass:: Overloaded Constructor with two arguments'); } public void display(){ System.out.println('val1 === '+val1 + ' ; val2 === '+val2 ); } } class Main{ public static void main(String args()){ DemoClass d1 = new DemoClass(); //object with no-args Constructor d1.display(); DemoClass d2 = new DemoClass(10); //object with 1 arg Constructor d2.display(); DemoClass d3 = new DemoClass(20,40); //object with 2 arg Constructor d3.display(); } }

Ieșire:

Suprasolicitat - ieșire

În programul de mai sus, avem o clasă care conține trei constructori. Primul constructor este un constructor fără argumente, iar apoi avem câte unul cu câte un argument și respectiv două argumente. Deoarece constructorul are o listă unică de parametri, putem spune că constructorii sunt supraîncărcați.

‘This ()’ Constructor In Java

Într-o clasă care conține mai mulți constructori, ce se întâmplă dacă vrem să numim un constructor dintr-un alt constructor din această clasă?

În acest scop, folosim cuvântul cheie „acesta” în interiorul constructorului din care dorim să apelăm un alt constructor.

Deci, atunci când o clasă are mai mulți constructori, un constructor fără argumente și un constructor parametrizat, folosim cuvântul cheie „acest” pentru a apela un constructor parametrizat din constructorul fără argumente. Aceasta se mai numește „Invocarea explicită a constructorului”.

De ce avem nevoie de acest cuvânt cheie?

Avem nevoie de el, deoarece invocarea explicită a constructorilor nu este posibilă direct folosind doar numele constructorului.

Puncte de reținut:

Cuvântul cheie „acesta” ar trebui să fie prima afirmație din constructorul apelant.
Dacă un constructor are „acest” cuvânt cheie, atunci nu poate avea „super”. Aceasta înseamnă că constructorul poate avea super sau asta.

class TestClass { TestClass() { //calling Parameterized Constructor this('SoftwareTestingHelp'); System.out.println('TestClass::No-args Constructor'); } TestClass(String str) { System.out.println('TestClass:: Parameterized Constructor(String):' + str); } } class Main{ public static void main(String() args) { TestClass obj = new TestClass(); } }

Ieșire:

Constructorul ‘this ()’ în Java

În programul de mai sus, avem un „TestClass” cu doi constructori. Numim asta („SoftwareTestingHelp”) din constructorul no-args. Aceasta este invocarea explicită a constructorului parametrizat.

Copiați constructorul în Java

Suntem conștienți de constructorul copiei în C ++. Constructorul de copiere este un constructor care are ca argument o referință de obiect și se creează un nou obiect folosind datele obiectului de referință.

C ++ oferă un constructor implicit de copiere dacă nu este furnizat în program.

Java oferă, de asemenea, suport pentru constructorul de copiere, dar nu oferă un constructor de copiere implicit.

Următorul program Java demonstrează constructorul copierii folosind exemplul clasic al numerelor complexe care au componente reale și imaginare.

class Complex { private double real, imaginary; // parametrized constructor public Complex(double real, double imaginary) { System.out.println('Complex:: parametrized constructor'); this.real = real; this.imaginary = imaginary; } // copy constructor Complex(Complex c) { System.out.println('Complex::Copy constructor called'); real = c.real; imaginary = c.imaginary; } // Overriding the toString of Object class @Override public String toString() { return '(' + real + ' + ' + imaginary + 'i)'; } } public class Main { public static void main(String() args) { Complex c1 = new Complex(1, 5); //calls parametrized constructor System.out.println('C1 = ' + c1); // copy constructor called Complex c2 = new Complex(c1); System.out.println('C2 = ' + c2); // this is a simple assignment operator Complex c3 = c2; } }

Ieșire:

Copiați constructorul în Java 7

Programul de mai sus are o clasă „Complex” care are un constructor parametrizat și un constructor de copiere. În prima metodă principală, creăm un obiect c1 folosind un constructor parametrizat. Apoi, folosind declarația de mai jos,

Complex c2 = new Complex (c1);

Instrucțiunea de mai sus apelează constructorul copiei, deoarece referința c1 este transmisă constructorului în timp ce creează un nou obiect c2.

Înlănțuirea constructorului în Java

Înlănțuirea constructorilor este un proces al unui constructor care numește un alt constructor din aceeași clasă.

Chiar și atunci când am moștenit dintr-o clasă de bază, constructorul clasei de bază este invocat mai întâi atunci când este creat obiectul clasei copil. Acesta este, de asemenea, un exemplu de înlănțuire a constructorilor.

În Java, înlănțuirea constructorului poate fi realizată folosind două abordări:

În cadrul aceleiași clase : Când apelăm un constructor de la un alt constructor din aceeași clasă, putem folosi acest cuvânt cheie ().
Din clasa de bază: Un constructor al clasei de bază poate fi apelat de cel al clasei derivate folosind cuvântul cheie super.

De ce avem nevoie de înlănțuirea constructorilor?

Când vrem să realizăm mai multe sarcini în constructorul nostru, atunci în loc să efectuăm fiecare sarcină într-un singur constructor, împărțim sarcinile în mai mulți constructori și apoi apelăm constructori unul de la altul, rezultând înlănțuirea constructorului.

Prezentate mai jos sunt câteva dintre regulile pe care trebuie să le urmăm în timp ce executăm înlănțuirea constructorului.

Înlănțuirea constructorului se face în orice ordine și va produce aceleași rezultate.
Expresia „acest” cuvânt cheie ar trebui să fie prima expresie din constructor.
Ar trebui să avem cel puțin un constructor fără acest cuvânt cheie.

Când avem o moștenire în programul nostru, putem efectua și înlănțuirea constructorilor. În acest caz, subclasa va apela la constructorul clasei de bază. Realizând această subclasă, crearea obiectelor începe cu inițializarea membrilor superclasei.

Acum vom implementa înlănțuirea constructorului în Java folosind abordările de mai sus.

# 1) Înlănțuirea constructorului în aceeași clasă

class DemoClass { // No args constructor DemoClass() { System.out.println('DemoClass::No args constructor'); } // parameterized constructor DemoClass(int val1) { // calls default constructor this(); System.out.println('DemoClass::Constructor with 1 argument: ' + val1); } // parameterized constructor DemoClass(int val1, int val2) { // invokes parameterized constructor with 1 argument this(5); System.out.print('DemoClass::constructor with 2 arguments:'); System.out.println('Product of 2 arguments = ' + val1 * val2); } } class Main{ public static void main(String args()) { // call parameterized constructor with 2 arguments new DemoClass(10, 15); } }

Ieșire:

înlănțuind în cadrul aceleiași clase

După cum sa menționat deja, realizăm înlănțuirea constructorului în cadrul aceleiași clase folosind cuvântul cheie „acest”. În programul de mai sus, avem trei constructori și numim un constructor din altul folosind cuvântul cheie „acest”.

Din clasa de bază

Când o clasă moștenește o altă clasă, atunci constructorul clasei părinte este invocat mai întâi atunci când creăm un obiect al unei clase derivate care este înlănțuirea constructorului.

Dacă vrem să apelăm în mod explicit constructorul clasei de bază din clasa derivată, atunci ar trebui să folosim cuvântul cheie „super” în acest scop. Folosind cuvântul cheie „super” putem apela constructorii superclasei din ierarhia moștenirii până când ajungem la cea mai înaltă clasă.

Programul de mai jos demonstrează utilizarea unui cuvânt cheie „super” pentru înlănțuirea constructorilor.

class BaseClass { String name; // no args constructor BaseClass() { this(''); System.out.println('BaseClass::No-argument constructor'); } // Parameterized constructor BaseClass(String name) { this.name = name; System.out.println('BaseClass::Parameterized constructor'); } } class DerivedClass extends BaseClass { // No-argument constructor DerivedClass() { System.out.println('DerivedClass::No-argument constructor'); } // parameterized constructor DerivedClass(String name) { super(name); // invokes Parameterized constructor of BaseClass System.out.println('DerivedClass::Parameterized constructor'); } } class Main { public static void main(String args()) { // invokes DerivedClass parameterized constructor DerivedClass obj = new DerivedClass('Java'); } }

Ieșire:

Din clasa de bază

În programul de mai sus, invocăm constructorul parametrizat al clasei derivate cu valoarea „Java”. La rândul său, acest constructor are un apel către constructorul clasei de bază folosind „super (nume);” care execută constructorul parametrizat al clasei de bază.

întrebări frecvente

Q # 1) Cum creezi un constructor în Java?

Răspuns: Creăm un constructor ca o metodă specială care are același nume ca și numele clasei. Un constructor nu poate avea și un tip de returnare. Poate avea modificatori de acces, dar nu poate fi final, static, abstract sau sincronizat.

Dacă ABC este o clasă, atunci îi putem defini constructorul ca

ABC(){} //no args constructor OR ABC(param1, param 2, …, param n) {} //parameterized constructor

Q # 2) Care este beneficiul unui constructor în Java?

Răspuns: Folosind constructorul, putem inițializa membrii clasei ca primul lucru în momentul în care obiectul este creat. Constructor elimină necesitatea de a apela implicit metodele normale.

Putem efectua diverse sarcini legate de inițializare, pornire sarcini etc. în constructor, deoarece constructorii sunt invocați în timpul fazei de creare a obiectelor.

Î # 3) De ce se utilizează constructorii?

Răspuns: Constructorii sunt utilizați în principal pentru a inițializa membrii clasei și sunt invocați atunci când obiectul clasei este creat.

Q # 4) Constructorul poate fi privat?

Răspuns: Da, putem avea un constructor privat. Când constructorul este privat, atunci clasa poate fi împiedicată să instanțeze.

Q # 5) Constructorul poate fi definitiv?

Răspuns: Nu, nu putem avea un constructor final.

Concluzie

În acest tutorial, am început discuția noastră despre constructorii în Java. Am învățat elementele de bază ale constructorului, crearea acestuia și regulile de urmat. De asemenea, am discutat despre constructorii de copii în Java.

Constructorul implicit și tipurile de constructori și concepte precum supraîncărcarea constructorului și înlănțuirea constructorului au fost prezentate cu exemple. Ca parte a acestor subiecte, am văzut și utilizarea cuvântului cheie „acest” în constructori.

=> Citiți seria Easy Training Java.

Java Constructor - Constructori de clasă, copiere și implicită