Introducere în constructor în Java
Constructorii din Java sunt tipuri speciale de metode care sunt utilizate pentru inițializarea obiectelor clasei. Constructorii sunt numiți la momentul creării obiectului clasei. La fel ca metodele, deși dețin un set de linii de cod, ele sunt destul de diferite de ele. Constructorii au același nume ca și clasa Java, dar nu are niciun tip de returnare. În Java, un cuvânt cheie nou () utilizat pentru a crea un obiect și de fiecare dată este creat un obiect nou și este apelat un constructor. Constructorul este apelat după ce memoria este alocată obiectului. În momentul creării obiectului, constructorii sunt obișnuiți să inițializeze valorile variabilelor de clasă, fie implicite, fie cele dorite.
Dacă utilizatorul nu creează niciun constructor în program, Java în sine creează un constructor implicit pentru acesta și atribuie valori implicite diferitelor obiecte, cum ar fi pentru valoarea implicită numerică, este 0, pentru un caracter ('\ 0') și variabile de referință ca nule . La fel ca metodele, constructorii pot fi supraîncărcați, adică o singură clasă poate avea mulți constructori dacă toți au o semnătură unică.
Sintaxa de bază a Constructorului în Java este dată mai jos:
Sintaxă
public class Student() // name of the class
(
. . . .
. . . .
. . . .
Student() // this is Constructor with the same name of class
(
. . .
. . .
)
new Student(); // object creation and value initialization
)
În sintaxa de mai sus, Student () este numele constructorului, care este același cu numele clasei și obiectele din Java sunt create folosind cuvântul cheie new.
Cum funcționează Constructorul în Java?
Pentru a înțelege funcționarea Constructorilor în Java, să luăm un exemplu dat mai jos:
Cod
public class Student()
(
int rollno;
String name;
Student(int rollno, String name)
(
this.rollno = rollno;
this.name = name;
)
public static void main(String() args)
(
Student st = new Student(12, 'Ananya');
System.out.println(“Student name = ”+ st.name + “Student rollno = ”+st.rollno);
)
)
producție
În exemplul de mai sus, avem variabile de instanță (variabile de clasă). Rola nr și numele și st Este numele obiectului creat al clasei Student. Când obiectul st este creat, invocă elevul constructor și inițializează variabilele de clasă cu valoarea rollno ca 12 și numele ca „Ananya”, altfel valorile implicite precum 0 pentru rollno și null pentru nume vor fi alocate variabilelor. Prin urmare, după atribuirea valorilor și tipărirea lor, numele studentului este tipărit ca Ananya și Student rollno 12.
Tipuri de constructori în Java
Există 2 tipuri de constructori în Java pe baza parametrilor:
1. Non-parametrizat / Fără argumente Constructor
Atunci când nu transmitem argumente în constructor, acel constructor este cunoscut ca un constructor nepermetriizat sau fără argumente. Când programatorul nu definește niciun constructor din programul Java, atunci compilatorul Java în sine adaugă un constructor în el, cunoscut ca constructor implicit, care furnizează valori implicite obiectului ca 0, nul, etc. Constructorul implicit nu este un tip special de constructor. dar se încadrează în categoria constructorului fără argumente.
Exemplu (constructor implicit)
Cod
public class Hello()
(
String name;
void display() //method to display name the value of variables
(
System.out.println(“name is” +name);
)
)
public class HelloMain()
(
public static void main(String() args)
(
Hello h1 = new Hello();
h1.display();
)
)
ieşire:
În exemplul de mai sus, acesta nu este niciun constructor definit de programator, astfel încât compilatorul va trata acest program ca:
Cod
public class Hello()
(
String name;
Hello() //default constructor created by compiler
(
name = null
)
void display()
(
System.out.println(“name is” +name);
)
)
public class HelloMain()
(
public static void main(String() args)
(
Hello h1 = new Hello();
h1.display();
)
)
Exemplu (constructor non-parametrizat)
Cod
public DemoProgram() // class
(
DemoProgram() // constructor with no arguments
(
System.out.println(“Hello this is just an example of no-arg constructor”);
)
public static void main(String() args)
(
new DermoProgram();
)
)
ieşire:
La fel ca în exemplul de mai sus, pentru constructorul DemoProgram () nu există argumente transmise, doar mesajul este tipărit și, prin urmare, este cunoscut ca No-argument constructor.
2. Constructor parametrizat
Constructorii parametrizați sunt acei constructori în care trecem argumentele sau parametrii. În acest constructor, valorile sunt transmise la momentul creării obiectului.
Exemplu (constructori parametrizați)
Cod
public class Animal()
(
int legs;
String sound;
Animal(int legs, String sound) // parameterized constructor
(
this.legs = legs; // values with get initialize of what is passed while object crea-this.sound = sound; // tion, ie (4, “bow bow”)
)
void display() // method to display the values
(
System.out.println(“Legs are ”+legs+“Sound is ”+sound);
)
)
class AnimalPlanet()
(
Public static void main(String() args)
(
Animal an = new Animal(4, “bow bow”);
an.display();
)
)
ieşire:
În exemplul de mai sus, valoarea 4 este atribuită picioarelor și șirul „arcul” este atribuit sunetului în constructorul Animal. Deci, atunci când afișarea metodei este numită ambele valori sunt imprimate în ieșire.
Puncte importante de reținut
- Fiecare clasă are un constructor indiferent dacă programatorul îl creează sau nu.
- Numele constructorului trebuie să fie același cu numele clasei.
- Constructorul nu are un tip de retur, spre deosebire de metodele.
- acest () și super () cuvânt cheie trebuie să fie prima afirmație dintr-un constructor.
- La fel ca metodele, constructorii pot fi supraîncărcați.
- Constructorii nu pot fi ignorați.
- Un constructor poate invoca un alt constructor din aceeași clasă folosind cuvântul cheie this ().
- Specificații / modificatori de acces pot fi aplicați înainte de numele constructorului pentru a declara scopul acestuia într-o clasă.
- În Java, un constructor nu poate fi niciodată static, final, abstract și sincronizat.
Concluzie
Constructorii joacă un rol important atunci când vine vorba de lucrul cu limbajul de programare Java. Trebuie să înțelegeți conceptele complete de Constructor, diverse tipuri de constructori, Construcția înlănțuire, cuvântul super () utilizat pentru a chema constructorul părinte să funcționeze în funcție de scenariul specific. Deși lucrul cu constructorii în Java este foarte ușor precum lucrul cu metode, dar există câteva puncte specifice constructorilor care ar trebui învățați amănunțit.
Articol recomandat
Acesta este un ghid pentru constructorul din Java. Aici vom discuta despre modul în care constructorul funcționează în Java împreună cu tipurile și exemplele cu implementarea codului adecvat. puteți, de asemenea, să parcurgeți articolele noastre sugerate pentru a afla mai multe-
- Constructor în JavaScript și tipuri
- Introducere în constructor în Python
- Constructor în C ++ și Tipuri
- Constructor în PHP (Exemple)