Introduktion til statisk konstruktør i Java

En statisk konstruktør er det stykke kode, der bruges til at initialisere statiske data, hvilket betyder, at en bestemt opgave kun skal udføres en gang i hele programmet. Det kaldes normalt automatisk, før der refereres til statiske medlemmer, eller der genereres en første instans. En statisk konstruktør er den, der eksplicit erklæres ved hjælp af det "statiske" nøgleord. En konstruktør må ikke være statisk, abstrakt, endelig, native, synkroniseret eller strictfp i Java.

De har et par unikke funktioner som følger:

  • Parametre eller adgangsmodifikatorer tages ikke af en statisk konstruktør.
  • En bestemt klasse kan kun have en enkelt statisk konstruktør.
  • Arv eller overbelastning er ikke tilladt i statiske konstruktører.
  • Det kan ikke kaldes direkte, da det altid kaldes automatisk.
  • Hvis de statiske feltinitialiseringsværdier ikke er angivet, initialiseres det til deres standardværdi som i tabellen Standardværdier.

Syntaks :

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

Her prøver vi at erklære en konstruktør i klassen ved at definere den som statisk. Når en sådan kode er samlet, får vi en fejlmeddelelse om, at ulovlig modifikator bruges til konstruktøren i type, og kun offentlig, beskyttet og privat er tilladt.

Arbejder med statisk konstruktør i Java

Konstruktører må ikke være statiske i Java på grund af følgende grund:

I Java gælder statiske metoder og variabler for klasserne. Men en konstruktør kaldes, når en ny operatør bruges til at oprette en instans. Da det ikke hører til ejendomsklassen, er det ikke tilladt at være statisk. Hvis en konstruktør anses for at være statisk, kan den ikke fås adgang til et objekt i dets underklasse.

Men hvis en konstruktør får lov til at være statisk, kan man få adgang til den inden for klassen, men ikke af dens underklasse. Det kan heller ikke arves, hvilket betyder, at de tilhører den klasse, de erklæres. At tillade en statisk konstruktør overtræder hele arvebegrebet, hvorfor det er ulovligt.

Eksempler på statisk konstruktør i Java

Vi kan forstå begrebet Static Constructor i Java bedre i følgende eksempler:

Eksempel 1

Kode:

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

Produktion:

Her får vi en fejl i kompileringstiden, hvor vi fortæller os, at statisk modifikator ikke er tilladt for medarbejder () -konstruktør i klassen Medarbejder (), da vi kalder det samme ved at oprette et nyt objekt nedenfor. Dette kan løses ved ikke at erklære det som statisk. Tjek eksemplet herunder for det samme.

Eksempel 2

Vi er nødt til at oprette 2 klasser i den samme pakke; ParentExample.java og ChildExample.java, der strækker sig fra sin overordnede klasse.

Kode:

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

Kør nu ChildExample.java.

Produktion:

Observationer:

  • Både forældre- og barneklasse har standardkonstruktører uden argumenter og en meddelelse udskrevet for at gøre udførelsen flydende.
  • Statisk konstruktør er den første kodeblok, der kører i klassen, da de udføres straks, når den respektive klassekørsel starter.
  • Underklassen tilsidesætter metoden til displaymeddelelse () og udskriver meddelelsen.
  • Vi har oprettet et nyt objekt i klassen ChildExample, der udfører den første superklasse-konstruktør og derefter den anden underklasse.
  • Til sidst aktiveres visningsmetoden for det nyoprettede objekt for at vise meddelelsen.
  • I sådanne tilfælde, hvor arv implementeres, kaldes konstruktørerne enten eksplicit eller implicit. Derfor bør det gøres ikke-statisk, så det er tilgængeligt.
  • Når det gøres til en statisk, bliver den tilknyttet en bestemt klasse end dens forekomster, og vil derfor ikke være tilgængelig under objektindstart.

Eksempel 3

I dette eksempel skal vi kombinere både ovennævnte statiske og ikke-statiske konstruktører og kontrollere gennemførelsen heraf.

Kode:

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

Produktion:

Begrænsninger af statisk konstruktør i Java

Her er nogle begrænsninger af statisk konstruktør i java nedenfor:

  • Konstruktørnavne kan ikke være eksplicitte, og det skal være obligatorisk det samme som dets klassens navn. Da de er begrænset til disse konventioner, kan der ikke gives flere læsbare navne til dem.
  • Hver gang en konstruktør skal kaldes, skal der oprettes et nyt objekt. Dette påvirker også udførelsen af ​​koden og gør det derfor langsomt.
  • Returneringstyper af konstruktører er begrænset til at returnere den samme type som objektet.
  • Vi kan ikke bruge statiske konstruktører i underklassekonstruktion, da implementering af kun superklassekonstruktører er tilladt.
  • En statisk konstruktør tillader ikke brugen af ​​"dette" nøgleord at få adgang til en instans.
  • Test krævede kræfter er mere, hvor statiske konstruktører er involveret.

Konklusion

En konstruktørs hovedopgave er at initialisere et objekt, og som det ses af alle ovenstående eksempler må en konstruktør ikke være statisk af hovedårsagen til, at objektet i en underklasse og andre ikke-statiske medlemmer ikke kan få adgang til det. Alternativet til den statiske konstruktør er ved at bruge statiske kodeblokke til at initialisere statiske variabler i en klasse.

Anbefalede artikler

Dette er en guide til Static Constructor i Java. Her diskuterer vi arbejdet, begrænsningerne og eksemplerne på statiske konstruktører i java i java sammen med deres implementering. Du kan også se på de følgende artikler for at lære mere–

  1. HashMap i Java
  2. JavaFX FileChooser
  3. JavaFX TextField
  4. JavaFX-knap
  5. Eksempler på JavaScript-statisk metode

Kategori:

Softwareudvikling