Introduktion till statisk konstruktör i Java
En statisk konstruktör är den kodkod som används för att initialisera statiska data, vilket innebär att en viss uppgift behöver utföras endast en gång under hela programmet. Det kallas vanligtvis automatiskt innan några statiska medlemmar hänvisas eller en första instans genereras. En statisk konstruktör är den som uttryckligen förklaras med hjälp av det "statiska" nyckelordet. En konstruktör får inte vara statisk, abstrakt, slutlig, infödd, synkroniserad eller striktfp i Java.
De har några unika funktioner enligt följande:
- Parametrar eller åtkomstmodifierare tas inte av en statisk konstruktör.
- En specifik klass kan endast ha en enda statisk konstruktör.
- Arv eller överbelastning är inte tillåtet i statiska konstruktörer.
- Det kan inte ringas direkt eftersom det alltid åberopas automatiskt.
- Om de statiska fälten initialiseringsvärden inte tillhandahålls initialiseras det till deras standardvärde som i tabellen Standardvärden.
Syntax :
public class (
private ;
public static () ()
)
Här försöker vi förklara en konstruktör i klassen genom att definiera den som statisk. När en sådan kod sammanställs får vi ett felmeddelande om att olaglig modifierare används för konstruktören i typ och endast offentliga, skyddade och privata är tillåtna.
Arbetar med statisk konstruktör i Java
Konstruktörer får inte vara statiska i Java på grund av följande skäl:
I Java gäller statiska metoder och variabler för klasserna. Men en konstruktör kallas när en ny operatör används för att skapa en instans. Eftersom den inte tillhör fastighetsklassen får den inte vara statisk. Om en konstruktör anses vara statisk kan den inte nås av ett objekt i dess underklass.
Men om en konstruktör tillåts vara statisk så kan den nås inom klassen men inte av dess underklass. Det kan inte heller ärvas vilket innebär att de tillhör den klass de förklaras. Att tillåta en statisk konstruktör bryter med hela arvet och är därför olagligt.
Exempel på statisk konstruktör i Java
Vi kan förstå konceptet Static Constructor i Java bättre i följande exempel:
Exempel 1
Koda:
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:
Här får vi felet i kompileringstiden som berättar för oss att den modifierande statiken inte är tillåten för anställd () -konstruktör i klassen Employee () eftersom vi ringer samma sak genom att skapa ett nytt objekt nedan. Detta kan lösas genom att inte förklara det som statiskt. Se exemplet nedan för samma.
Exempel 2
Vi måste skapa två klasser i samma paket; ParentExample.java och ChildExample.java som sträcker sig från sin överordnade klass.
Koda:
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 förälder- och barnklassen har standardkonstruktörer utan argument och ett meddelande som skrivs ut för att göra körningen klar.
- Statisk konstruktör är det första kodblocket som körs i klassen eftersom de körs omedelbart när respektive klassutförande startar.
- Underklassen åsidosätter metoden för visning av meddelanden () och skriver ut meddelandet.
- Vi har skapat ett nytt objekt i klassen ChildExample som kör den första superklasskonstruktören och sedan den andra underklassen.
- Till sist anropas visningsmetoden för det nyskapade objektet för att visa meddelandet.
- I sådana fall där arv implementeras, kallas konstruktörerna antingen uttryckligen eller implicit. Därför bör den göras icke-statisk så att den är tillgänglig.
- När det görs en statisk, blir den associerad med en specifik klass än dess instanser och kommer därför inte att vara tillgänglig under objektinställning.
Exempel 3
I det här exemplet ska vi kombinera båda ovanstående statiska och icke-statiska konstruktörer och kontrollera dess genomförande.
Koda:
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änsningar av statisk konstruktör i Java
Här är några begränsningar för statisk konstruktör i java nedan:
- Konstruktörens namn kan inte vara uttryckliga och det måste vara obligatoriskt samma som dess klassnamn. Eftersom de är begränsade till dessa konventioner kan inte mer läsbara namn ges dem.
- Varje gång en konstruktör behöver kallas måste ett nytt objekt skapas. Detta påverkar också kodens prestanda och gör det så långsamt.
- Returtyper av konstruktörer är begränsade till att returnera samma typ som för objektet.
- Vi kan inte använda statiska konstruktörer i underklasskonstruktion eftersom implementering av endast superklasskonstruktörer är tillåtet.
- En statisk konstruktör tillåter inte användning av "detta" nyckelord för att komma åt en instans.
- Testinsatser som krävs är mer när det gäller statiska konstruktörer.
Slutsats
En konstruktörs huvudsakliga uppgift är att initialisera ett objekt och som ses av alla ovanstående exempel får en konstruktör inte vara statisk av huvudorsaken att objektet för en underklass och andra icke-statiska medlemmar inte kan nås av det. Alternativet till den statiska konstruktorn är att använda statiska kodblock för att initialisera statiska variabler i en klass.
Rekommenderade artiklar
Detta är en guide till Static Constructor i Java. Här diskuterar vi arbetet, begränsningarna och exemplen på statiska konstruktörer i java i java tillsammans med deras implementering. Du kan också titta på följande artiklar för att lära dig mer–
- HashMap i Java
- JavaFX FileChooser
- JavaFX TextField
- JavaFX-knapp
- Exempel på JavaScript-statisk metod