java constructor class
En aquest tutorial es parlarà de Java Constructor, els seus tipus i conceptes com la sobrecàrrega de constructors i la cadena de constructors amb exemples de codi:
Dels nostres tutorials anteriors, sabem que la instància d’una classe s’anomena objecte. Un objecte d'una classe es crea mitjançant la paraula clau 'nova'. Un mètode especial anomenat 'constructor' es diu quan creem un objecte amb una paraula clau nova o quan l'objecte s'instancia.
Un constructor es defineix com un bloc de codi per inicialitzar l'objecte de classe. És idèntic al mètode però no és un mètode. No obstant això, es pot anomenar com a 'mètode especial' a Java.
=> Consulteu aquí per veure aquí A-Z de tutorials de formació.
Què aprendreu:
- Java Constructor
- Conclusió
Java Constructor
El constructor Java s’utilitza per inicialitzar l’objecte acabat de crear. Un objecte ha de tenir algunes dades abans d’utilitzar-les al programa. Per tant, fem servir el constructor per poder assignar algunes dades inicials a l'objecte.
Com a exemple simple, considerem una classe ABC per a la qual hem de crear un objecte. Creem un objecte 'myObj' per a la classe ABC mitjançant una paraula clau nova.
ABC myObj = new ABC ();
La sentència anterior crea un objecte myObj. Quan es crea aquest objecte, es diu un constructor de la classe ABC sense arguments (ABC () representa que no hi ha arguments per al constructor). Com que no es proporcionen arguments per al constructor anterior, els camps membres de myObj s'inicialitzaran als seus valors inicials per defecte.
Per exemple,
- Els tipus de dades numèriques com int s’estableixen a 0.
- El valor variable del tipus de dades de caràcters està definit com a caràcter nul (' 0').
- Les referències es defineixen com a nul·les.
En aquest tutorial, parlarem detalladament dels constructors juntament amb els diversos constructors utilitzats a Java.
Com es crea un constructor a Java
Per crear un constructor a Java, hem de seguir certes regles tal com s’indica a continuació.
- El constructor de classes té el mateix nom que el de la classe.
- No hi pot haver un constructor final, abstracte, sincronitzat o estàtic. Això es deu al fet que el Final actua com un abstracte constant i constant que no es pot instanciar. Mentre que sincronitzat s'utilitza en el cas de multi threading, i la paraula clau estàtica s'utilitza a nivell de classe.
- Podem utilitzar modificadors d’accés amb els constructors.
- Un constructor no pot tenir un tipus de retorn.
Per exemple,definim un alumne de la classe de la següent manera:
class Student{ String name; int roll_no; }
Podem crear objectes de la classe anterior amb la nova paraula clau. Mentre es crea l'objecte, podem inicialitzar les variables de dos membres d'aquesta classe proporcionant un constructor. Tingueu en compte que, fins i tot si no proporcionem un constructor i només executem la sentència següent,
Estudiant = estudiant nou ();
Tot i això, Java executarà un constructor per defecte que inicialitzarà les variables de dos membres per defecte al sistema. Ara, si volem que el valor inicial de Student.name sigui “Keith” i que roll_no sigui 27, llavors per fer-ho podem crear el següent mètode constructor.
Student () { name = 'Keith'; roll_no = 27; }
Quan creem un objecte de la classe de l’alumne amb l’enunciat següent
Student student = new Student ();
A continuació, els valors inicials de les variables membres nom i roll_no seran Keith i 27 respectivament.
Ara que es crea un constructor, quan es cridarà?
Es diu un constructor cada vegada que es crea un objecte amb la nova paraula clau, com en el cas anterior. Com ja s'ha esmentat, si no es proporciona cap constructor, Java proporciona un constructor per defecte que es crida quan es crea l'objecte amb la nova paraula clau.
Exemple de constructor
El programa següent mostra un exemple de constructor en el qual tenim un constructor senzill sense arguments. Aquest constructor simplement assigna valors inicials a les seves variables membres.
//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(); } }
Sortida:
Constructor per defecte a Java
El constructor per defecte també es diu Constructor buit . Aquest compilador és inserit pel compilador Java al codi de classe on no hi ha cap constructor implementat pel programador. El constructor per defecte s’insereix durant la compilació i, per tant, només apareixerà al fitxer ‘.class’ i no al codi font.
Penseu en la següent classe Java.
fitxer font (.java) fitxer de classe (.class)
A la figura anterior, la primera figura mostra el codi font en què no hem especificat cap constructor. Així, quan compilem aquest codi i es genera el fitxer .class, podem veure que el compilador Java ha inserit un constructor per defecte tal com es mostra a la figura adjunta (en color blau).
Nota:
De vegades, s'utilitza un constructor per defecte per descriure un constructor no-arg a Java. Però aquests dos termes són diferents en realitat. El constructor no-arg és un tipus de constructor a Java especificat pel programador. El constructor per defecte és el constructor que insereix el compilador Java.
millor eina de neteja per a PC
Per tant, tot i que aquests dos termes són utilitzats indistintament per la majoria del programador, és recomanable no confondre aquests dos termes.
Quan Java insereix un constructor per defecte, si el programa té alguna variable, se'ls assignen els valors per defecte.
La taula següent mostra els valors predeterminats de cada tipus de dades.
Tipus | Valor per defecte |
---|---|
char | u0000 |
Objecte | Referència nul·la |
booleà | fals |
byte | 0 |
curt | 0 |
int | 0 |
llarg | 0L |
flotar | 0,0f |
doble | 0,0d |
El programa següent proporciona un exemple de constructor per defecte a 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); } }
Sortida:
Tipus de constructors a Java
Hi ha dos tipus de constructors a Java com es mostra a continuació.
# 1) No-arg Constructor
Un constructor sense arguments s'anomena no-args o constructor sense arguments. Si no tenim un constructor sense arguments, el compilador Java no crea un constructor per defecte per a la classe.
En general, si definim un constructor a la nostra classe, el compilador Java no inserirà el constructor per defecte.
A continuació es mostra un exemple del 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(); } }
Sortida:
En aquest programa, hem proporcionat un constructor no-args. Aquí, imprimim alguns missatges que inclouen les variables membres. Podem veure a la sortida que es mostren els missatges del constructor que indiquen que el constructor no-args està executat.
# 2) Constructor parametritzat
Un constructor parametritzat té un o més paràmetres. Podem utilitzar un constructor parametritzat en cas que necessitem passar alguns valors inicials a la variable membre de la classe.
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); } }
Sortida:
Aquí hem proporcionat un constructor parametritzat que pren dos arguments, és a dir, nom i identificador.
Dins del cos del constructor, els arguments s’assignen com a valors al nom i l’identificador de les variables membre respectivament.
A continuació, al mètode principal, quan creem un objecte nou amb la nova paraula clau, passem dos valors al nom de la classe després d’una nova paraula clau. Això indica que anomenem el constructor parametritzat. Quan mostrem les variables membres, podem veure que tenen els valors que hem passat mentre creavem l'objecte.
Constructors sobrecarregats a Java
Ara sorgeix la pregunta de si una classe pot tenir més d’un constructor o és que una classe només pot tenir un constructor?
Bé, podem tenir diversos constructors en una classe. Una classe pot tenir tants constructors sempre que estigui sobrecarregada correctament.
Llavors, què s’entén exactament per sobrecàrrega de constructors?
La sobrecàrrega del constructor és un mecanisme que permet a una classe tenir tants constructors de manera que tots aquests constructors tinguin llistes de paràmetres diferents, depenent dels tipus de paràmetres o de l'ordre dels paràmetres.
El programa següent mostra la sobrecàrrega del constructor.
//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(); } }
Sortida:
Al programa anterior, tenim una classe que conté tres constructors. El primer constructor és un constructor sense arg, i després en tenim un amb un argument i dos arguments respectivament. Com que el constructor té una llista de paràmetres única, podem dir que els constructors estan sobrecarregats.
‘This ()’ Constructor In Java
En una classe que conté múltiples constructors, què passa si volem anomenar un constructor d’un altre constructor d’aquesta classe?
Amb aquest propòsit, fem servir la paraula clau 'això' dins del constructor des del qual volem anomenar un altre constructor.
Per tant, quan una classe té diversos constructors, un constructor sense arg i un constructor parametritzat, fem servir aquesta paraula clau per cridar a un constructor parametritzat des del constructor sense arg. Això també es diu 'Invocació explícita del constructor'.
Per què necessitem aquesta paraula clau?
La necessitem perquè la invocació explícita dels constructors no és possible directament només utilitzant el nom del constructor.
Punts a tenir en compte:
- La paraula clau 'això' hauria de ser la primera afirmació del constructor de trucades.
- Si un constructor té 'aquesta' paraula clau, no pot tenir 'super'. Això significa que el constructor pot tenir super o això.
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(); } }
Sortida:
Al programa anterior, tenim un ‘TestClass’ amb dos constructors. Anomenem això ('SoftwareTestingHelp') des del constructor no-args. Aquesta és la invocació explícita del constructor parametritzat.
Copia el constructor a Java
Coneixem el constructor de còpies a C ++. El constructor de còpia és un constructor que té una referència d'objecte com a argument i es crea un nou objecte utilitzant les dades de l'objecte de referència.
C ++ proporciona un constructor de còpia per defecte si no se'n proporciona cap al programa.
Java també proporciona suport per al constructor de còpies, però no proporciona un constructor de còpia per defecte.
El següent programa Java mostra el constructor de còpies amb l'exemple clàssic de nombres complexos que tenen components reals i imaginaris.
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; } }
Sortida:
El programa anterior té una classe ‘Complex’ que té un constructor parametritzat i un constructor de còpia. Primer, en el mètode principal, creem un objecte c1 mitjançant un constructor parametritzat. A continuació, utilitzeu la sentència següent,
Complex c2 = new Complex (c1);
La sentència anterior crida al constructor de còpia ja que la referència c1 es passa al constructor mentre es crea un nou objecte c2.
Encadenament de constructors a Java
L’encadenament de constructors és un procés que un constructor crida a un altre constructor de la mateixa classe.
Fins i tot quan hem heretat d'una classe base, el constructor de la classe base s'invoca primer quan es crea l'objecte de classe fill. Aquest és també un exemple d'encadenament de constructors.
A Java, la cadena de constructors es pot aconseguir utilitzant dos enfocaments:
- Dins de la mateixa classe : Quan trucem a un constructor d'un altre constructor de la mateixa classe, podem utilitzar aquesta paraula clau ().
- De la classe base: Un constructor de la classe base es pot anomenar pel de la classe derivada mitjançant la paraula clau super.
Per què necessitem un encadenament de constructors?
Quan volem realitzar diverses tasques al nostre constructor, en lloc de realitzar cada tasca en un constructor, desglossem les tasques en múltiples constructors i, a continuació, anomenem constructors els uns dels altres, donant lloc a un encadenament de constructors.
A continuació es detallen algunes de les regles que hem de seguir mentre realitzem l'encadenament de constructors.
- L'encadenament del constructor es fa en qualsevol ordre i produirà els mateixos resultats.
- L'expressió 'aquesta' paraula clau hauria de ser la primera expressió del constructor.
- Hauríem de tenir almenys un constructor sense aquesta paraula clau.
Quan tenim una herència al nostre programa, també podem realitzar un encadenament de constructors. En aquest cas, la subclasse cridarà al constructor de la classe base. Fent això, la creació d’objectes de subclasse comença amb la inicialització dels membres de la superclasse.
Ara implementarem el constructor encadenat a Java utilitzant els enfocaments anteriors.
# 1) Constructor encadenat dins de la mateixa classe
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); } }
Sortida:
Com ja s'ha esmentat, aconseguim un encadenament de constructors dins de la mateixa classe mitjançant la paraula clau 'aquesta'. Al programa anterior, tenim tres constructors i anomenem un constructor d’un altre fent servir aquesta paraula clau.
De la classe base
Quan una classe hereta una altra classe, aleshores s’invoca el constructor de la classe pare quan creem un objecte d’una classe derivada que és un encadenament de constructors.
com es reprodueix l’objecte flash d’ona de xoc
Si volem trucar explícitament al constructor de classes base de la classe derivada, hauríem d'utilitzar la paraula clau 'super' per a aquest propòsit. Mitjançant la paraula clau “super” podem anomenar els constructors de superclasses de la jerarquia d’herències fins que arribem a la classe més alta.
El programa següent mostra l’ús d’una paraula clau ‘súper’ per encadenar constructors.
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'); } }
Sortida:
Al programa anterior, invocem el constructor parametritzat de la classe derivada amb el valor “Java”. Al seu torn, aquest constructor fa una crida al constructor de la classe base mitjançant 'super (nom);' que executa el constructor parametritzat de la classe base.
Preguntes freqüents
P # 1) Com es crea un constructor a Java?
Resposta: Creem un constructor com a mètode especial que porta el mateix nom que el nom de la classe. Un constructor no pot tenir un tipus de retorn també. Pot tenir modificadors d’accés però no pot ser final, estàtic, abstracte o sincronitzat.
Si ABC és una classe, podem definir el seu constructor com
ABC(){} //no args constructor OR ABC(param1, param 2, …, param n) {} //parameterized constructor
Q # 2) Quin avantatge té un constructor a Java?
Resposta: Utilitzant el constructor, podem inicialitzar els membres de la classe com el primer que es crea l'objecte. Constructor elimina la necessitat de trucar implícitament als mètodes normals.
Podem realitzar diverses tasques relacionades amb la inicialització, l’inici de tasques, etc. al constructor a mesura que s’invocen els constructors durant la fase de creació d’objectes.
P # 3) Per què s’utilitzen els constructors?
Resposta: Els constructors s’utilitzen principalment per inicialitzar els membres de la classe i s’invoca quan es crea l’objecte de la classe.
P # 4) El constructor pot ser privat?
Resposta: Sí, podem tenir un constructor privat. Quan el constructor és privat, es pot evitar que la classe instanciï.
P # 5) El constructor pot ser definitiu?
Resposta: No, no podem tenir un constructor final.
Conclusió
En aquest tutorial, hem començat la nostra discussió sobre constructors a Java. Hem après els conceptes bàsics del constructor, la seva creació i les regles a seguir. També vam parlar de constructors de còpies a Java.
El constructor per defecte i els tipus de constructors i conceptes com la sobrecàrrega del constructor i l'encadenament del constructor es van resumir amb exemples. Com a part d’aquests temes, també vam veure l’ús d’aquesta paraula clau en els constructors.
=> Llegiu la sèrie de formació Java fàcil.
Lectura recomanada
- Objecte Java Class Vs: com s'utilitza la classe i l'objecte a Java
- Conceptes bàsics de Java: sintaxi de Java, Java Class i conceptes bàsics de Java
- Java Integer i Java BigInteger Class amb exemples
- Tutorial de classe de Java Scanner amb exemples
- Tutorial de classe Java Array: classe java.util.Arrays amb exemples
- Què és Java Vector | Tutorial de Java Vector Class amb exemples
- Interfície Java i tutoria de classes abstractes amb exemples
- Classe de robots a Selenium WebDriver amb Java