Einführung in Static Constructor in Java
Ein statischer Konstruktor ist der Code, der zum Initialisieren statischer Daten verwendet wird. Dies bedeutet, dass eine bestimmte Aufgabe im gesamten Programm nur einmal ausgeführt werden muss. Es wird normalerweise automatisch aufgerufen, bevor auf statische Member verwiesen wird oder eine erste Instanz generiert wird. Ein statischer Konstruktor wird explizit mit dem Schlüsselwort "static" deklariert. Ein Konstruktor darf in Java nicht statisch, abstrakt, final, nativ, synchronisiert oder strictfp sein.
Sie haben einige einzigartige Eigenschaften wie folgt:
- Parameter oder Zugriffsmodifikatoren werden nicht von einem statischen Konstruktor verwendet.
- Eine bestimmte Klasse kann nur einen einzelnen statischen Konstruktor besitzen.
- Vererbung oder Überladung ist in statischen Konstruktoren nicht zulässig.
- Es kann nicht direkt aufgerufen werden, da es immer automatisch aufgerufen wird.
- Wenn die Initialisierungswerte für statische Felder nicht angegeben werden, wird sie auf ihren Standardwert wie in der Tabelle Standardwerte initialisiert.
Syntax :
public class (
private ;
public static () ()
)
Hier versuchen wir, einen Konstruktor in der Klasse zu deklarieren, indem wir ihn als statisch definieren. Wenn ein solcher Code kompiliert wird, erhalten wir eine Fehlermeldung, die besagt, dass für den Konstruktor der Typ Illegal Modifier verwendet wird und nur public, protected und private zulässig sind.
Arbeiten mit Static Constructor in Java
Konstruktoren dürfen in Java aus folgendem Grund nicht statisch sein:
In Java gelten statische Methoden und Variablen für die Klassen. Ein Konstruktor wird jedoch aufgerufen, wenn ein neuer Operator zum Erstellen einer Instanz verwendet wird. Da es nicht zur Eigenschaftsklasse gehört, darf es nicht statisch sein. Wenn ein Konstruktor als statisch angesehen wird, kann ein Objekt seiner Unterklasse nicht auf ihn zugreifen.
Wenn ein Konstruktor jedoch statisch sein darf, kann auf ihn innerhalb der Klasse zugegriffen werden, jedoch nicht über seine Unterklasse. Es kann auch nicht vererbt werden, was bedeutet, dass sie zu der Klasse gehören, für die sie deklariert wurden. Das Zulassen eines statischen Konstruktors verstößt gegen das gesamte Konzept der Vererbung und ist daher illegal.
Beispiele für Static Constructor in Java
Das Konzept des Static Constructor in Java können wir in den folgenden Beispielen besser verstehen:
Beispiel 1
Code:
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();
)
)
Ausgabe:
Hier erhalten wir einen Kompilierungsfehler, der uns mitteilt, dass der Modifikator static für den Employee () -Konstruktor in der Employee () -Klasse nicht zulässig ist, da wir dasselbe aufrufen, indem wir unten ein neues Objekt erstellen. Dies kann gelöst werden, indem es nicht als statisch deklariert wird. Schauen Sie sich das folgende Beispiel an.
Beispiel # 2
Wir müssen 2 Klassen innerhalb desselben Pakets erstellen. ParentExample.java und ChildExample.java, die von der übergeordneten Klasse ausgehen.
Code:
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();
)
)
Führen Sie nun die ChildExample.java aus.
Ausgabe:
Beobachtungen:
- Sowohl die Parent- als auch die Child-Klasse verfügen über Standardkonstruktoren ohne Argumente und eine Meldung, die den Ausführungsfluss verdeutlicht.
- Der statische Konstruktor ist der erste Codeblock, der in der Klasse ausgeführt wird, da er sofort ausgeführt wird, wenn die jeweilige Klassenausführung beginnt.
- Die Unterklasse überschreibt die Methode display message () und gibt die Nachricht aus.
- Wir haben ein neues Objekt der ChildExample-Klasse erstellt, das den ersten Superklassenkonstruktor und dann die zweite Unterklasse ausführt.
- Zuletzt wird die Anzeigemethode des neu erstellten Objekts aufgerufen, um die Nachricht anzuzeigen.
- In solchen Fällen, in denen die Vererbung implementiert ist, werden die Konstruktoren entweder explizit oder implizit aufgerufen. Daher sollte es nicht statisch gemacht werden, damit es zugänglich ist.
- Wenn es zu einer statischen Klasse gemacht wird, wird es einer bestimmten Klasse als ihren Instanzen zugeordnet und ist daher während der Objektinstanziierung nicht verfügbar.
Beispiel # 3
In diesem Beispiel kombinieren wir die obigen statischen und nicht statischen Konstruktoren und überprüfen ihre Implementierung.
Code:
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();
)
)
Ausgabe:
Einschränkungen des statischen Konstruktors in Java
Im Folgenden sind einige Einschränkungen des statischen Konstruktors in Java aufgeführt:
- Konstruktornamen können keine expliziten Namen sein und müssen zwingend mit dem Klassennamen übereinstimmen. Da sie auf diese Konventionen beschränkt sind, können ihnen keine besser lesbaren Namen gegeben werden.
- Jedes Mal, wenn ein Konstruktor aufgerufen werden muss, muss ein neues Objekt erstellt werden. Dies wirkt sich auch auf die Leistung des Codes aus und verlangsamt diesen.
- Rückgabetypen von Konstruktoren können nur denselben Typ wie der des Objekts zurückgeben.
- Wir können keine statischen Konstruktoren in Unterklassenkonstruktionen verwenden, da nur die Implementierung von Superklassenkonstruktoren zulässig ist.
- Ein statischer Konstruktor erlaubt nicht die Verwendung des Schlüsselworts "this", um auf eine Instanz zuzugreifen.
- Der erforderliche Testaufwand ist größer, wenn statische Konstruktoren beteiligt sind.
Fazit
Die Hauptaufgabe eines Konstruktors besteht darin, ein Objekt zu initialisieren. Wie aus allen obigen Beispielen hervorgeht, darf ein Konstruktor nicht statisch sein, da er nicht auf das Objekt einer Unterklasse und andere nicht statische Elemente zugreifen kann. Die Alternative zum statischen Konstruktor besteht darin, statische Codeblöcke zu verwenden, um statische Variablen einer Klasse zu initialisieren.
Empfohlene Artikel
Dies ist eine Anleitung zum Static Constructor in Java. Hier diskutieren wir die Funktionsweise, Einschränkungen und Beispiele von statischen Konstruktoren in Java in Java sowie deren Implementierung. Weitere Informationen finden Sie auch in den folgenden Artikeln.
- HashMap in Java
- JavaFX FileChooser
- JavaFX TextField
- JavaFX-Schaltfläche
- Beispiele für statische JavaScript-Methoden