Introducere în Static Constructor în Java
Un constructor static este bucata de cod folosită pentru inițializarea datelor statice, ceea ce înseamnă că o anumită sarcină trebuie executată o singură dată pe tot parcursul programului. De obicei este apelat automat înainte ca orice membru static să facă referire sau să fie generată o primă instanță. Un constructor static este cel care este declarat explicit folosind cuvântul cheie „static”. Un constructor nu are voie să fie static, abstract, final, nativ, sincronizat sau strictfp în Java.
Acestea au câteva caracteristici unice, după cum urmează:
- Parametrii sau modificatorii de acces nu sunt luați de un constructor static.
- O clasă specifică poate avea doar un singur constructor static.
- Moștenirea sau supraîncărcarea nu este permisă în constructorii statici.
- Nu poate fi apelat direct, deoarece este invocat întotdeauna automat.
- Dacă valorile de inițializare a câmpurilor statice nu sunt furnizate, acesta se inițializează la valoarea implicită ca în tabelul Valori implicite.
Sintaxa :
public class (
private ;
public static () ()
)
Aici încercăm să declaram un constructor din clasă definindu-l ca static. Când un astfel de cod este compilat, primim un mesaj de eroare care afirmă că modificatorul ilegal este utilizat pentru constructor în tip și sunt permise doar publice, protejate și private.
Funcționarea constructorului static în Java
Constructorii nu au voie să fie statici în Java din următorul motiv:
În Java, metodele și variabilele statice se aplică claselor. Dar un constructor este apelat atunci când un nou operator este folosit pentru a crea o instanță. Deoarece nu aparține clasei de proprietăți, nu este permis să fie static. Dacă în cazul în care un constructor este considerat a fi static, acesta nu poate fi accesat de un obiect al subclasei sale.
Dar dacă unui constructor i se permite să fie static, acesta poate fi accesat în cadrul clasei, dar nu prin subclasa sa. De asemenea, nu se poate moșteni ceea ce înseamnă că aparțin clasei pe care sunt declarați. Permiterea unui constructor static încalcă întregul concept de moștenire, deci este ilegal.
Exemple de Static Constructor în Java
Putem înțelege mai bine conceptul de Static Constructor în Java în următoarele exemple:
Exemplul # 1
Cod:
public class Employee (
//Initialising variables for employee name and ID
public String emp_name;
public int emp_id;
//Declaration of the static constructor
public static Employee()(
System.out.println("Printing Constructor of the Employee class");
)
//Declaring method to print message
public void displayMsg()(
System.out.println("Employee Name is: "+this.emp_name );
System.out.println("Employee ID is: "+this.emp_id );
)
public static void main(String args()) (
//Creating a new object to call the display message constructor
new Employee().displayMsg();
)
)
ieşire:
Aici primim o eroare de timp de compilare care ne spune că modificatorul static nu este permis pentru constructorul Employee () din clasa Employee (), deoarece apelăm la fel prin crearea unui nou obiect mai jos. Acest lucru poate fi rezolvat prin a nu-l declara ca static. Consultați exemplul de mai jos pentru același lucru.
Exemplul # 2
Trebuie să creăm 2 clase în cadrul aceluiași pachet; ParentExample.java și ChildExample.java care se extinde din clasa părintească.
Cod:
ParentExample.java:
public class ParentExample (
ParentExample()(
super();
System.out.println("Printing Super constructor inside Parent class");
)
void displayMessage()(
System.out.println("Printing inside display Message class");
)
)
ChildExample.java:
public class ChildExample extends ParentExample (
ChildExample()(
super();
System.out.println("Printing super constructor inside child class");
)
@Override
void displayMessage()(
System.out.println("Printing display message inside Parent example");
)
public static void main(String() args)(
ChildExample childexample = new ChildExample();
childexample.displayMessage();
)
)
Executați acum ChildExample.java.
ieşire:
observaţii:
- Atât clasa Părinte cât și Copil au construiți implicit fără argumente și un mesaj tipărit pentru a face curgerea execuției.
- Constructorul static este primul bloc de cod care se execută în clasă, deoarece acestea sunt executate imediat la începerea execuției clasei respective.
- Subclasa înlocuiește metoda afișării mesajului () și tipărește mesajul.
- Am creat un nou obiect al clasei ChildExample care execută primul constructor de superclase și apoi a doua subclasă.
- În cele din urmă, metoda de afișare a obiectului nou creat este invocată pentru a afișa mesajul.
- În astfel de cazuri în care moștenirea este pusă în aplicare, constructorii sunt numiți explicit sau implicit. Prin urmare, ar trebui să fie făcut nestatic pentru a fi accesibil.
- Când este făcută una statică, atunci se asociază cu o clasă specifică decât instanțele sale și, prin urmare, nu vor fi disponibile în timpul instantării obiectului.
Exemplul # 3
În acest exemplu, vom combina atât constructorii statici cât și cei nestatici de mai sus și vom verifica implementarea acestuia.
Cod:
class ParentClass(
private static String message= "Test message";
// Declaring a nested static class
public static class StaticNestedClass(
// In the nested class only static members belonging to parent class can be accessed
// in a static nested class
public void displayprint() (
// We get a compiler error if we try and make this message
// a non-static variable
System.out.println("Displaying from nested class: " + message);
)
)
// Declaring Inner class or also called non-static nested class
public class ChildClass(
// The static and non-static constructor both can be accessed in
// this Child class
public void displayprint()(
System.out.println("Printing from static non-nested class: "+ message);
)
)
)
class Main
(
public static void main(String args())(
// Instance of static nested class creation
ParentClass.StaticNestedClass printer = new ParentClass.StaticNestedClass();
//Calling the non-static constructor of static nested class
printer.displayprint();
// Creating Parent class instance first in order
//to create the child class instance
ParentClass outer = new ParentClass();
ParentClass.ChildClass inner = outer.new ChildClass();
// Here we call the non-static method of Child class
inner.displayprint();
// Creation of instance for child class in one line
//by combining above 2 lines
ParentClass.ChildClass innerObject = new ParentClass().new ChildClass();
// Now we call the child method
innerObject.displayprint();
)
)
ieşire:
Limitări ale constructorului static în Java
Iată câteva limitări ale constructorului static din java, date mai jos:
- Numele constructorului nu poate fi unul explicit și trebuie obligatoriu același cu numele clasei sale. Din moment ce sunt limitate la aceste convenții, nu le pot fi date nume mai lizibile.
- De fiecare dată când un constructor trebuie apelat, trebuie creat un obiect nou. Acest lucru afectează, de asemenea, performanța codului, ceea ce îl face lent.
- Tipurile de returnare a constructorilor sunt restricționate să returneze același tip cu cel al obiectului.
- Nu putem folosi constructori statici în construcția subclasei, deoarece implementarea numai a constructorilor de superclase este permisă.
- Un constructor static nu permite folosirea cuvântului cheie „acest” pentru a accesa o instanță.
- Eforturile de testare necesare sunt mai multe în cazul în care sunt implicați constructori statici.
Concluzie
Sarcina principală a unui constructor este de inițializare a unui obiect și așa cum se vede din toate exemplele de mai sus, unui constructor nu i se permite să fie static din motivul principal pentru care obiectul unei subclase și alți membri care nu sunt statici nu pot fi accesați de acesta. Alternativa la constructorul static este folosind blocuri statice de cod pentru inițializarea variabilelor statice ale unei clase.
Articole recomandate
Acesta este un ghid pentru Static Constructor în Java. Aici discutăm modul de lucru, limitările și exemple de constructori statici în java în java împreună cu implementarea lor. De asemenea, puteți consulta următoarele articole pentru a afla mai multe -
- HashMap în Java
- JavaFX FileChooser
- JavaFX TextField
- Butonul JavaFX
- Exemple de metoda statică JavaScript