Introductie van Static Constructor op Java

Een statische constructor is het stuk code dat wordt gebruikt om statische gegevens te initialiseren, wat betekent dat een bepaalde taak slechts eenmaal in het programma hoeft te worden uitgevoerd. Het wordt meestal automatisch aangeroepen voordat naar statische leden wordt verwezen of een eerste exemplaar wordt gegenereerd. Een statische constructor is degene die expliciet wordt aangegeven met behulp van het trefwoord "statisch". Een constructor mag in Java niet statisch, abstract, finaal, native, gesynchroniseerd of strictfp zijn.

Ze hebben een paar unieke kenmerken als volgt:

  • Parameters of toegangsmodificatoren worden niet door een statische constructor overgenomen.
  • Een specifieke klasse kan slechts één statische constructor bezitten.
  • Overerving of overbelasting is niet toegestaan ​​in statische constructors.
  • Het kan niet direct worden aangeroepen, omdat het altijd automatisch wordt aangeroepen.
  • Als de initialisatiewaarden van de statische velden niet worden opgegeven, wordt deze geïnitialiseerd naar hun standaardwaarde zoals in de tabel Standaardwaarden.

Syntaxis :

public class (
private ;
public static () ()
)

Hier proberen we een constructor in de klasse te verklaren door deze als statisch te definiëren. Wanneer een dergelijke code wordt gecompileerd, krijgen we een foutmelding dat Illegale modifier wordt gebruikt voor de constructor in type en alleen publiek, beveiligd en privé zijn toegestaan.

Werken van Static Constructor op Java

Constructeurs mogen om de volgende reden niet statisch zijn in Java:

In Java zijn statische methoden en variabelen van toepassing op de klassen. Maar een constructor wordt opgeroepen wanneer een nieuwe operator wordt gebruikt om een ​​instantie te maken. Omdat het niet tot de eigenschapsklasse behoort, mag het niet statisch zijn. Als een constructor als statisch wordt beschouwd, kan deze niet worden benaderd door een object van zijn subklasse.

Maar als een constructor statisch mag zijn, kan deze binnen de klasse worden benaderd, maar niet via de subklasse. Het kan ook niet worden geërfd, wat betekent dat ze behoren tot de klasse die ze zijn verklaard. Het toestaan ​​van een statische constructeur is in strijd met het hele concept van overerving en is dus illegaal.

Voorbeelden van statische constructor in Java

We kunnen het concept van Static Constructor in Java beter begrijpen in de volgende voorbeelden:

Voorbeeld 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();
)
)

Output:

Hier krijgen we een compilatietijdfout die aangeeft dat de statische modifier niet is toegestaan ​​voor Employee () constructor in de klasse Employee (), omdat we hetzelfde aanroepen door hieronder een nieuw object te maken. Dit kan worden opgelost door het niet als statisch te verklaren. Bekijk het onderstaande voorbeeld voor hetzelfde.

Voorbeeld 2

We moeten 2 klassen binnen hetzelfde pakket maken; ParentExample.java en ChildExample.java die zich uitstrekt van de bovenliggende klasse.

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();
)
)

Voer nu de ChildExample.java uit.

Output:

opmerkingen:

  • Zowel de klasse Ouder als Kind heeft standaardconstructors zonder argumenten en een bericht wordt afgedrukt om de uitvoering duidelijk te maken.
  • Statische constructor is het eerste codeblok dat in de klasse wordt uitgevoerd, omdat deze onmiddellijk worden uitgevoerd wanneer de uitvoering van de respectieve klasse begint.
  • De subklasse overschrijft de methode display message () en drukt het bericht af.
  • We hebben een nieuw object van de klasse ChildExample gemaakt dat de eerste constructeur van de superklasse uitvoert en vervolgens de tweede subklasse.
  • Eindelijk wordt de weergavemethode van het nieuw gemaakte object aangeroepen om het bericht weer te geven.
  • In dergelijke gevallen waarin overerving wordt geïmplementeerd, worden de constructors expliciet of impliciet genoemd. Daarom moet het niet-statisch worden gemaakt zodat het toegankelijk is.
  • Wanneer het een statische wordt gemaakt, wordt het geassocieerd met een specifieke klasse dan zijn instanties en is het daarom niet beschikbaar tijdens object-instantiëring.

Voorbeeld 3

In dit voorbeeld zullen we beide bovengenoemde statische en niet-statische constructors combineren en de implementatie ervan controleren.

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();
)
)

Output:

Beperkingen van statische constructor in Java

Hier zijn enkele beperkingen van statische constructor in Java hieronder:

  • Namen van constructeurs kunnen niet expliciet zijn en moeten verplicht hetzelfde zijn als de klassennaam. Omdat ze beperkt zijn tot deze conventies, kunnen er geen leesbare namen aan worden gegeven.
  • Telkens wanneer een constructor moet worden aangeroepen, moet een nieuw object worden gemaakt. Dit heeft ook invloed op de prestaties van de code, waardoor deze traag wordt.
  • Retourtypen van constructors zijn beperkt om hetzelfde type als dat van het object te retourneren.
  • We kunnen geen statische constructors gebruiken in de subklasseconstructie omdat de implementatie van alleen superklasseconstructors is toegestaan.
  • Een statische constructor staat het gebruik van "dit" sleutelwoord niet toe om toegang te krijgen tot een instantie.
  • De vereiste testinspanningen zijn meer waar statische constructeurs bij betrokken zijn.

Conclusie

De hoofdtaak van een constructor is het initialiseren van een object en zoals blijkt uit alle bovenstaande voorbeelden, is het een constructor niet toegestaan ​​statisch te zijn om de belangrijkste reden dat het object van een subklasse en andere niet-statische leden er niet door kunnen worden benaderd. Het alternatief voor de statische constructor is door statische blokken code te gebruiken om statische variabelen van een klasse te initialiseren.

Aanbevolen artikelen

Dit is een gids voor Static Constructor op Java. Hier bespreken we de werking, beperkingen en voorbeelden van statische constructors in Java in Java, samen met hun implementatie. U kunt ook de volgende artikelen bekijken voor meer informatie–

  1. HashMap in Java
  2. JavaFX FileChooser
  3. JavaFX TextField
  4. JavaFX-knop
  5. Voorbeelden van statische JavaScript-methode

Categorie:

Software ontwikkeling