A Java, encadenament del constructor és una seqüència d'invocació constructors en inicialitzar un objecte. S'utilitza quan volem invocar una sèrie de constructors, un darrere l'altre utilitzant només una instància. En aquesta secció, parlarem encadenant de constructors a Java en detall amb exemples adequats. Fem una ullada ràpida què és un constructor en Java.
Constructor
En Java , un constructor és el mateix que un mètode però l'única diferència és que el constructor té el mateix nom que el nom de la classe. S'utilitza per crear una instància de la classe. Es crida automàticament quan creem un objecte de la classe. No té cap tipus de retorn. Recordeu que un constructor no pot ser abstracte , final , sincronitzat , i estàtica . No podem anul·lar un constructor.
Hi ha dos tipus de constructors a Java:
- Constructor predeterminat (també conegut com a constructor sense argument)
- Constructor parametritzat
Encadenat de constructors
A la cadena de constructors, s'anomena un constructor des d'un altre constructor de la mateixa classe com aquest procés es coneix encadenament del constructor. Es produeix per herència. Quan creem una instància d'una classe derivada, primer s'invoquen tots els constructors de la classe heretada (classe base), després s'invoca el constructor de la classe que crida (classe derivada).
Podem aconseguir l'encadenament del constructor de dues maneres:
unions i tipus d'unions
Recordeu que canviar l'ordre del constructor no afecta la sortida.
La necessitat de l'encadenament de constructors
Suposem que hi ha cinc tasques a realitzar. Hi ha dues maneres de realitzar aquestes tasques, implementar totes les tasques en un únic constructor o crear tasques separades en un únic constructor.
Mitjançant el mecanisme d'encadenament del constructor, podem implementar diverses tasques en un únic constructor. Per tant, sempre que ens enfrontem a aquest tipus de problemes, hauríem d'utilitzar l'encadenament de constructors. Podem fer que el programa sigui més llegible i entenedor utilitzant l'encadenament del constructor.
matriu dinàmica java
Regles d'encadenament de constructors
- Una expressió que utilitza això La paraula clau ha de ser la primera línia del constructor.
- Hi ha d'haver almenys un constructor que no utilitzi això
Constructor Crida a un altre Constructor
La crida del constructor es pot fer de dues maneres:
Nota: En el mateix bloc constructor, no podem utilitzar this() i super() simultàniament.
Entendrem aquests dos conceptes a través de programes Java.
Exemples d'encadenament de constructors
Cridant al constructor de classe actual
Fem servir això () paraula clau si volem cridar al constructor de classe actual dins de la mateixa classe. L'ús d'aquest() és obligatori perquè JVM mai ho poseu automàticament com el super() paraula clau. Tingueu en compte que this() ha de ser la primera línia del constructor. Hi ha d'existir almenys un constructor sense aquesta paraula clau (). .
Sintaxi:
this(); or this(parameters list);
Per exemple:
this(); this('Javatpoint');
Creem un programa Java i cridem al constructor de classe actual.
ConstructorChain.java
public class ConstructorChain { //default constructor ConstructorChain() { this('Javatpoint'); System.out.println('Default constructor called.'); } //parameterized constructor ConstructorChain(String str) { System.out.println('Parameterized constructor called'); } //main method public static void main(String args[]) { //initializes the instance of example class ConstructorChain cc = new ConstructorChain(); } } Sortida:
A l'exemple anterior, hem creat una instància de la classe sense passar cap paràmetre. Primer crida al constructor predeterminat i el constructor predeterminat redirigeix la trucada al parametrat a causa d'això (). Les sentències dins del constructor parametritzat s'executen i tornen al constructor predeterminat. Després d'això, s'executen la resta de les declaracions del constructor predeterminat i l'objecte s'inicia amb èxit. La següent és la seqüència de crida del constructor:
ConstructorChain cc = new ConstructorChain(); -> ConstructorChain() -> ConstructorChain(String str) -> System.out.println() -> ConstructorChain() -> System.out.println()
Trucant a Super Class Constructor
De vegades, hem de cridar al constructor de la superclasse (classe pare) des de la classe fill (classe derivada) en aquests casos, utilitzem la paraula clau super() al constructor de classes derivades. És opcional escriure super() perquè JVM ho posa automàticament. Sempre s'ha d'escriure a la primera línia. Obtenim un error de sintaxi si intentem cridar un constructor de superclasse a la classe fill.
l'actriu índia rani mukerji
Sintaxi:
super(); or super(Parameter List);
super(): Crida al constructor sense argument o predeterminat de la superclasse.
valor de cadena de
super (paràmetres): Invoca el constructor parametritzat de la superclasse.
Recordeu que el constructor de la superclasse no es pot heretar a la subclasse. Es pot cridar des del constructor de subclasses utilitzant la paraula clau super.
Creem un programa Java i implementem l'encadenament del constructor en una classe heretada.
ConstructorChaining.java
//parent class or base class class Demo { //base class default constructor Demo() { this(80, 90); System.out.println('Base class default constructor called'); } //base class parameterized constructor Demo(int x, int y) { System.out.println('Base class parameterized constructor called'); } } //derived class or child class class Prototype extends Demo { //derived class default constructor Prototype() { this('Java', 'Python'); System.out.println('Derived class default constructor called'); } //derived class parameterized constructor Prototype(String str1, String str2) { super(); System.out.println('Derived class parameterized constructor called'); } } public class ConstructorChaining { //main method public static void main(String args[]) { //initializes the instance of example class Prototype my_example = new Prototype(); } } Sortida:
