Úvod do statického konstruktoru v Javě
Statický konstruktor je část kódu používaného k inicializaci statických dat, což znamená, že určitá úloha musí být v programu provedena pouze jednou. Obvykle se volá automaticky před generováním referenčních statických členů nebo vygenerováním první instance. Statický konstruktor je konstrukt, který je explicitně deklarován pomocí klíčového slova „statický“. Konstruktor nesmí být v Javě statický, abstraktní, finální, nativní, synchronizovaný nebo přísný.
Mají několik jedinečných funkcí:
- Parametry nebo modifikátory přístupu nebere statický konstruktor.
- Specifická třída může mít pouze jeden statický konstruktor.
- U statických konstruktérů není dovoleno dědičnost nebo přetížení.
- Nelze jej vyvolat přímo, protože je vždy vyvolán automaticky.
- Pokud nejsou zadány inicializační hodnoty statických polí, inicializuje se na jejich výchozí hodnotu jako v tabulce Výchozí hodnoty.
Syntaxe :
public class (
private ;
public static () ()
)
Zde se snažíme deklarovat konstruktora ve třídě definováním jako statického. Při kompilaci takového kódu se zobrazí chybová zpráva, že nelegální modifikátor je používán pro konstruktor v typu a jsou povoleny pouze veřejné, chráněné a soukromé.
Práce statického konstruktoru v Javě
Konstruktory nesmí v Javě být statické, a to z následujícího důvodu:
V Javě se na třídy vztahují statické metody a proměnné. Konstruktor se však volá, když se k vytvoření instance použije nový operátor. Protože nepatří do třídy vlastností, není dovoleno být statické. Pokud je konstruktor považován za statický, nemůže k němu přistupovat objekt jeho podtřídy.
Pokud je konstruktoru dovoleno být statické, lze k němu přistupovat v rámci třídy, nikoli však prostřednictvím její podtřídy. Nelze také zdědit, což znamená, že patří do třídy, v níž jsou vyhlášeni. Povolení statického konstruktéra porušuje celý koncept dědičnosti, a proto je nezákonné.
Příklady statického konstruktoru v Javě
Koncept Static Constructor v jazyce Java můžeme lépe porozumět v následujících příkladech:
Příklad č. 1
Kód:
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();
)
)
Výstup:
Zde se zobrazuje chyba kompilace, která nám říká, že statický modifikátor není povolen pro konstruktor Employee () uvnitř třídy Employee (), protože to nazýváme vytvořením nového objektu níže. To lze vyřešit tak, že to nevyhlásíte jako statické. Podívejte se na níže uvedený příklad.
Příklad č. 2
Musíme vytvořit 2 třídy uvnitř stejného balíčku; ParentExample.java a ChildExample.java, které sahají z nadřazené třídy.
Kód:
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();
)
)
Nyní spusťte soubor ChildExample.java.
Výstup:
Pozorování:
- Třída Parent i Child mají výchozí konstruktory bez argumentů a zprávy, aby byl průběh provádění jasný.
- Statický konstruktor je první blok kódu, který se má spustit ve třídě, protože je spuštěn okamžitě při spuštění příslušné třídy.
- Podtřída přepíše metodu display message () a vytiskne zprávu.
- Vytvořili jsme nový objekt třídy ChildExample, který vykonává první konstrukt nadřazené třídy a poté druhou podtřídu.
- Nakonec je vyvolána metoda zobrazení nově vytvořeného objektu pro zobrazení zprávy.
- V takových případech, kdy je implementováno dědictví, jsou konstruktéři voláni explicitně nebo implicitně. Proto by měl být proveden jako nestatický, aby byl přístupný.
- Pokud je vytvořen jako statický, bude přidružen ke konkrétní třídě, než jsou její instance, a proto nebude během instance objektu k dispozici.
Příklad č. 3
V tomto příkladu budeme kombinovat oba výše uvedené statické a nestatické konstruktory a zkontrolujeme jeho implementaci.
Kód:
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();
)
)
Výstup:
Omezení statického konstruktoru v Javě
Níže uvádíme některá omezení statického konstruktoru v javě:
- Jména konstruktorů nemohou být jednoznačná a musí být povinně stejná jako název třídy. Protože jsou omezeny na tyto konvence, nemohou jim být dána čitelnější jména.
- Pokaždé, když je třeba zavolat konstruktoru, musí být vytvořen nový objekt. To také ovlivňuje výkonnost kódu a tím je zpomaluje.
- Návratové typy konstruktorů jsou omezeny na návrat stejného typu jako u objektu.
- V konstrukci podtřídy nemůžeme použít statické konstruktory, protože je povolena implementace pouze konstruktérů super třídy.
- Statický konstruktor neumožňuje použití klíčového slova „toto“ pro přístup k instanci.
- Požadované testovací úsilí je více tam, kde se jedná o statické konstruktéry.
Závěr
Hlavní úlohou konstruktoru je inicializovat objekt a jak je vidět ze všech výše uvedených příkladů, konstruktor nesmí být statický z toho důvodu, že objekt podtřídy a další nestatické členy nemohou získat přístup k němu. Alternativou k statickému konstruktoru je použití statických bloků kódu k inicializaci statických proměnných třídy.
Doporučené články
Toto je průvodce Static Constructor v Javě. Zde diskutujeme práci, omezení a příklady statických konstruktérů v javě v javě a jejich implementaci. Další informace naleznete také v následujících článcích -
- HashMap v Javě
- JavaFX FileChooser
- JavaFX TextField
- Tlačítko JavaFX
- Příklady statické metody JavaScriptu