Introduksjon til statisk konstruktør i Java
En statisk konstruktør er koden som brukes til å initialisere statiske data, noe som betyr at en bestemt oppgave bare må utføres en gang i løpet av programmet. Det kalles vanligvis automatisk før det blir generert noen statiske medlemmer eller en første instans. En statisk konstruktør er den som er eksplisitt erklært ved bruk av det "statiske" nøkkelordet. En konstruktør har ikke lov til å være statisk, abstrakt, endelig, innfødt, synkronisert eller strengfp i Java.
De har noen unike funksjoner som følger:
- Parametere eller tilgangsmodifiserere tas ikke av en statisk konstruktør.
- En spesifikk klasse kan bare ha en enkelt statisk konstruktør.
- Arv eller overbelastning er ikke tillatt i statiske konstruktører.
- Det kan ikke ringes direkte siden det alltid påberopes automatisk.
- Hvis initialiseringsverdiene for statiske felt ikke er oppgitt, initialiseres de til standardverdien som i tabellen Standardverdier.
Syntaks :
public class (
private ;
public static () ()
)
Her prøver vi å erklære en konstruktør i klassen ved å definere den som statisk. Når en slik kode er samlet, får vi en feilmelding som sier at ulovlig modifikator blir brukt for konstruktøren i type og bare offentlig, beskyttet og privat er tillatt.
Working of Static Constructor in Java
Konstruktører har ikke lov til å være statiske i Java på grunn av følgende årsak:
I Java gjelder statiske metoder og variabler for klassene. Men en konstruktør kalles når en ny operatør brukes til å opprette en instans. Siden den ikke tilhører eiendomsklassen, er det ikke lov å være statisk. Hvis en konstruktør anses for å være statisk, kan den ikke få tilgang til et objekt i underklassen.
Men hvis en konstruktør får lov å være statisk, kan du få tilgang til den i klassen, men ikke av underklassen. Det kan heller ikke arves noe som betyr at de tilhører klassen de er erklært. Å la en statisk konstruktør bryte hele arvebegrepet, og det er derfor ulovlig.
Eksempler på statisk konstruktør i Java
Vi kan forstå begrepet 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();
)
)
Produksjon:
Her får vi feil på kompileringstiden som forteller oss at statisk modifiserer ikke er tillatt for Employee () -konstruktør i klassen Employee () siden vi ringer det samme ved å opprette et nytt objekt nedenfor. Dette kan løses ved ikke å erklære det som statisk. Sjekk ut eksemplet nedenfor for det samme.
Eksempel 2
Vi må lage 2 klasser i samme pakke; ParentExample.java og ChildExample.java som strekker seg fra foreldreklassen.
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();
)
)
Nå kjører ChildExample.java.
Produksjon:
observasjoner:
- Både foreldre- og barneklasse har fått standardkonstruktører uten argumenter og en melding skrevet ut for å gjøre utførelsen flyt.
- Statisk konstruktør er den første kodeblokken som kjøres i klassen da de utføres umiddelbart når den respektive klassekjøringen starter.
- Underklassen overstyrer metoden for visning av melding () og skriver ut meldingen.
- Vi har laget et nytt objekt fra ChildExample-klassen som utfører den første superklasse-konstruktøren og deretter den andre underklassen.
- Endelig blir visningsmetoden til det nyopprettede objektet påkalt for å vise meldingen.
- I slike tilfeller hvor arv implementeres, kalles konstruktørene enten eksplisitt eller implisitt. Derfor bør den gjøres ikke-statisk slik at den er tilgjengelig.
- Når det blir gjort statisk, blir det assosiert med en spesifikk klasse enn forekomstene, og vil derfor ikke være tilgjengelig under objektinjisering.
Eksempel 3
I dette eksemplet skal vi kombinere begge de ovennevnte statiske og ikke-statiske konstruktørene og sjekke implementeringen.
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();
)
)
Produksjon:
Begrensninger av statisk konstruktør i Java
Her er noen begrensninger for statisk konstruktør i java gitt nedenfor:
- Konstruktørnavn kan ikke være eksplisitte, og det må være obligatorisk det samme som klassens navn. Siden de er begrenset til disse konvensjonene, kan ikke mer lesbare navn gis dem.
- Hver gang en konstruktør må ringes, må det opprettes et nytt objekt. Dette påvirker også ytelsen til koden og gjør den dermed treg.
- Returtyper av konstruktører er begrenset til å returnere samme type som gjenstandens.
- Vi kan ikke bruke statiske konstruktører i underklasse-konstruksjon da implementering av bare superklasse-konstruktører er tillatt.
- En statisk konstruktør tillater ikke bruk av "dette" nøkkelordet tilgang til en forekomst.
- Testinnsats som kreves er mer der statiske konstruktører er involvert.
Konklusjon
Hovedjobben til en konstruktør er å initialisere et objekt, og som vi ser fra alle eksemplene ovenfor, tillater ikke en konstruktør å være statisk av hovedgrunnen til at objektet til en underklasse og andre ikke-statiske medlemmer ikke kan nås av den. Alternativet til den statiske konstruktøren er ved å bruke statiske kodeblokker for å initialisere statiske variabler i en klasse.
Anbefalte artikler
Dette er en guide til Static Constructor i Java. Her diskuterer vi arbeid, begrensninger og eksempler på statiske konstruktører i java i java sammen med implementeringen av dem. Du kan også se på følgende artikler for å lære mer–
- HashMap i Java
- JavaFX FileChooser
- JavaFX TextField
- JavaFX-knapp
- Eksempler på JavaScript Static Method