Caracteristicile constructorului
- Numele constructorului trebuie să fie același cu numele clasei.
- Tipul de returnare este nul.
- Constructorul nu poate fi static, abstract și final.
Tipuri de constructor
- Mod implicit
- Fără parametri
- Parametrizat
1. Constructor implicit
Constructorul implicit este creat de compilatorul Java atunci când codificatorul nu declară niciun constructor pentru clasă și acest constructor nu conține niciun argument. Fișierul Java nu conține niciun cod pentru constructorul implicit. Codul constructor implicit este creat în momentul compilării codului Java și este stocat în .clasă fişier.
2. Constructor fără parametri
Când un constructor este declarat fără niciun parametru sau argument, atunci acesta este numit un constructor fără parametri. Un constructor fără parametri funcționează ca un constructor implicit și acest constructor poate conține instrucțiuni sau poate fi gol.
3. Constructor parametrizat
Când orice constructor este declarat cu unul sau mai mulți parametri, atunci se numește constructor parametrizat. Valorile parametrilor constructorului sunt transmise în momentul creării obiectului.
Exemplul 1: Crearea unui constructor fără parametri
Următorul cod arată cum să utilizați un constructor fără parametri. S-a menționat anterior că numele metodei constructorului va fi același cu numele clasei. Aici, numele clasei este „ con1 , ”Deci numele constructorului fără parametri este„ con1 () . ”Două variabile de clasă,„ Nume ' și ' vârstă , ’Sunt declarate aici. În momentul declarării variabilei obiect „ obiect , 'Constructorul va fi apelat și va fi tipărit un anumit mesaj. După aceea, două valori sunt atribuite în variabilele de clasă și sunt tipărite ulterior folosind „Obj” obiect.
public clasăcon1{// declarați variabile
Şir Nume;
intvârstă;
// Constructor fără parametri
con1() {
Sistem .afară.println(„Constructor este chemat”.);
// Inițializați variabilele
Nume= „Fahim Reza”;
vârstă= 30;
}
// metoda main ()
public static nulprincipal( Şir []argumente) {
// Creați un obiect
con1 obj= noucon1();
// Imprimați valorile proprietăților obiectului
Sistem .afară.imprimare('Vârsta ' +obiect.Nume + ' este ' +obiect.vârstă);
}
}
Ieșire:
Următoarea imagine arată ieșirea codului. Constructorul este apelat în momentul creării obiectului și al mesajului Constructor se numește este tipărit. Valorile „ Nume ' și ' vârstă Sunt atribuite în interiorul constructorului. Valorile acestor variabile sunt tipărite ulterior.
Exemplul 2: Creați un constructor parametrizat
Următorul cod va calcula salariul total al unui angajat pe baza salariului de bază și va imprima celelalte informații ale acelui angajat alături de salariul calculat. Aici sunt declarate șapte variabile de clasă. Constructorul, numit „ con2 () , ’Are trei parametri. Primii doi parametri vor lua valorile șirului din „ Nume ' și ' post Parametrii ', iar al treilea parametru va lua valoarea numerică în de bază 'Parametru. Valorile acestor parametri vor fi transmise în momentul creării obiectului. Constructorul va inițializa variabilele de clasă cu aceste valori și va calcula celelalte valori pe baza valorii „ de bază 'Parametru. Apoi, se vor tipări numele, postul și salariul angajatului.
public clasăcon2{// Declarați variabilele
Şir Nume;
Şir post;
intDe bază;
dublaChirie;
dublaMedical;
dublaTransport;
dublaSalariu;
// Constructor parametrizat
con2( Şir Nume, Şir post,intde bază) {
acest.Nume =Nume;
acest.post =post;
acest.De bază =de bază;
acest.Chirie =de bază*0,3;
acest.Medical =de bază*0,2;
acest.Transport =de bază*0,1;
Salariu=de bază+Chirie+Medical+Transport;
}
// metoda main ()
public static nulprincipal( Şir []argumente) {
// Creați un obiect
con2 obj= noucon2(„Mir Sabbir”,'Contabil',65000);
// Imprimați valorile proprietăților obiectului
Sistem .afară.imprimare('Numele angajatului: ' +obiect.Nume + ' n' + 'Post: '+obiect.post +
' n' + „Salariu: TK”+obiect.Salariu);
}
}
Ieșire:
Următoarea imagine arată ieșirea codului. Aici, numele angajatului, postul și salariul de bază sunt date în declarația de creare a obiectelor. Salariul total, numele și postul sunt tipărite aici.
Exemplul 3: Creați înlănțuirea constructorului
Este important să cunoașteți caracteristica de moștenire a programării orientate pe obiecte pentru a înțelege conceptul de înlănțuire a constructorilor. Când se creează o nouă clasă prin moștenirea altei clase, aceasta se numește moștenire. În acest caz, toate proprietățile părintelui sau ale clasei de bază sunt accesibile de la copilul sau clasa derivată. Când este creat un obiect al clasei copil, acesta apelează automat constructorul clasei părinte înainte de a apela propriul constructor. „ super() ’Metoda este utilizată în alte limbi pentru a apela constructorul părinte, dar compilatorul Java apelează automat această metodă. Utilizarea constructorilor în acest mod se numește înlănțuirea constructorului, iar acest proces este prezentat în acest exemplu. Aici, numele clasei părinte este „ mamă „Iar numele clasei copilului este„ con3 . ”Există o altă metodă numită„ combina() 'În clasa copil care combină valorile atribuite în constructorii părinte și copil.
clasămamă{// Declarați variabila
Şir strVal;
// Constructor părinte
mamă(){
Sistem .afară.println(„Constructorul părinte se numește”);
strVal= 'Imi place ';
}
}
public clasăcon3se extindemamă{
// Declarați variabila
Şir childStrVal;
// Constructor copil
con3(){
Sistem .afară.println(„Constructorul copilului se numește”);
childStrVal=strVal+ „Programare Java”;
}
// O altă metodă de combinare a șirurilor
Şir combina()
{
întoarcere acest.childStrVal;
}
// metoda main ()
public static nulprincipal( Şir []argumente) {
// Creați un obiect
con3 obj= noucon3();
// Imprimați valorile proprietăților obiectului
Sistem .afară.imprimare(obiect.combina());
}
}
Ieșire:
Următoarea imagine arată ieșirea codului. Primul mesaj este tipărit din constructorul părinte, în timp ce al doilea mesaj este tipărit din constructorul copil. Ultimul mesaj este tipărit apelând „ combina() ’Metoda.
Concluzie
Conceptul de constructor și utilizările diferiților constructori sunt explicate în acest tutorial utilizând exemple de cod Java ușor pe care utilizatorii începători le pot urmări. Sperăm că aceste exemple v-au ajutat să înțelegeți elementele de bază ale constructorului Java.