Bevezetés a Java statikus konstruktorába
A statikus konstruktor a statikus adatok inicializálásához használt kódrészlet, ami azt jelenti, hogy egy adott feladatot csak egyszer kell végrehajtani a program során. Általában automatikusan meghívják, mielőtt a hivatkozott statikus tagok vagy az első példányok generálódnak. A statikus konstruktort kifejezetten a „statikus” kulcsszóval deklarálják. A konstruktornak Java-ban nem szabad statikus, absztrakt, végleges, natív, szinkronizált vagy szigorú fájlrendszerű.
Néhány egyedi tulajdonsággal rendelkeznek, az alábbiak szerint:
- A paramétereket vagy a hozzáférés-módosítókat nem veszi statikus konstruktor.
- Egy adott osztály csak egyetlen statikus konstruktorral rendelkezhet.
- Az öröklés vagy a túlterhelés statikus konstruktorokban nem megengedett.
- Nem lehet közvetlenül meghívni, mivel mindig automatikusan meghívják.
- Ha a statikus mezők inicializálási értékeit nem adják meg, akkor az alapértelmezett értékre inicializálódnak, mint az Alapértelmezett értékek táblázatban.
Szintaxis :
public class (
private ;
public static () ()
)
Itt megpróbáljuk deklarálni egy konstruktort az osztályban, statikusnak definiálva. Amikor egy ilyen kódot összeállítunk, egy hibaüzenetet kapunk, amely kijelenti, hogy az illegális módosítót a konstruktor típusa használja, és csak nyilvános, védett és privát engedélyezett.
Statikus konstruktor működése Java-ban
A konstruktorok nem szabad statikusak Java-ban a következő ok miatt:
A Java-ban statikus módszerek és változók vonatkoznak az osztályokra. De egy konstruktort akkor hívnak meg, ha egy új operátort használnak példány létrehozására. Mivel nem tartozik az ingatlan osztályba, nem szabad statikus. Ha abban az esetben, ha egy konstruktort statikusnak tekintünk, akkor alosztályának tárgya nem fér hozzá hozzá.
De ha a konstruktor statikus lehet, akkor az osztályon belül elérhető, de az alosztálya nem érhető el. Ez sem örökölhető, ami azt jelenti, hogy azokhoz a osztályhoz tartoznak, amelyeket deklaráltak. Ha statikus konstruktort engedünk, megsértjük az öröklés teljes koncepcióját, tehát ez illegális.
Példák a Java statikus konstruktorára
A Java példában a statikus konstruktor fogalmát jobban megérthetjük a következő példákban:
1. példa
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();
)
)
Kimenet:
Itt egy összeállítási idő hibát kapunk, amely azt mondja nekünk, hogy a statikus módosító statikus nem engedélyezett az Employee () konstruktor számára az Employee () osztályon belül, mivel ugyanazt hívjuk azáltal, hogy alul létrehozunk egy új objektumot. Ez úgy oldható meg, hogy nem statikusnak nyilvánítja. Nézze meg ugyanezt az alábbi példában.
2. példa
Két osztályt kell létrehoznunk ugyanabban a csomagban; ParentExample.java és ChildExample.java, amely kiterjed a szülőosztályára.
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();
)
)
Most futtassa a ChildExample.java fájlt.
Kimenet:
Észrevételek:
- Mind a Szülő, mind a Gyerekek osztálya alapértelmezett konstruktorokkal rendelkezik, argumentumok nélkül és egy üzenetet nyomtatva, hogy a végrehajtás folyamata egyértelmű legyen.
- A statikus konstruktor az első olyan kódblokk, amely az osztályban fut, mivel azonnal végrehajtódnak, amikor a megfelelő osztályfutás elindul.
- Az alosztály felülbírálja a megjelenítési üzenet () módszert és kinyomtatja az üzenetet.
- Kidolgoztunk egy új objektumot a ChildExample osztályból, amely végrehajtja az első szuperosztály-konstruktort, majd a második alosztályt.
- Végül az újonnan létrehozott objektum megjelenítési módszerére hívjuk fel az üzenetet.
- Ilyen esetekben, amikor az öröklés megvalósul, az építőket kifejezetten vagy implicit módon hívják fel. Ezért nem statikusnak kell lennie, hogy hozzáférhető legyen.
- Ha statikussá teszik, akkor hozzákapcsolódik egy adott osztályhoz, mint a példányaihoz, ezért az objektum-megvalósítás során nem lesz elérhető.
3. példa
Ebben a példában a fenti statikus és nem statikus konstruktort egyaránt összekapcsoljuk, és ellenőrizzük annak megvalósítását.
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();
)
)
Kimenet:
A Java statikus kivitelezőjének korlátozásai
Az alábbiakban bemutatjuk a java statikus konstruktorának néhány korlátozását:
- A kivitelezők neve nem lehet explicit, és kötelezően meg kell egyeznie az osztály nevével. Mivel ezekre az egyezményekre korlátozódnak, olvasható nevek nem adhatók nekik.
- Minden alkalommal, amikor kivitelezőt kell hívni, új objektumot kell létrehozni. Ez befolyásolja a kód teljesítményét is, ezzel lassítva.
- A konstruktorok visszatérési típusai az objektuméval azonos típusú visszaadásra korlátozódnak.
- Az alosztály-konstrukcióban nem használhatunk statikus konstruktort, mivel csak a szuperosztályú konstruktorok megvalósítása megengedett.
- A statikus kivitelező nem engedélyezi az „ezen” kulcsszó használatát egy példány eléréséhez.
- A szükséges tesztelési erőfeszítések inkább statikus konstruktorok esetében vannak.
Következtetés
A konstruktor fő feladata egy objektum inicializálása, és amint az a fenti példákból kitűnik, a konstruktornak nem szabad statikusnak lennie fő okból, hogy az alosztály objektumához és más nem statikus tagokhoz ez nem érhető el. A statikus konstruktor alternatívája statikus kódblokkok használata az osztály statikus változóinak inicializálásához.
Ajánlott cikkek
Ez egy útmutató a Java statikus kivitelezőjéhez. Itt tárgyaljuk a java java-ban lévő statikus konstruktorok működését, korlátozásait és példáit, azok megvalósításával együtt. A következő cikkeket is megnézheti további információkért -
- HashMap Java
- JavaFX FileChooser
- JavaFX TextField
- JavaFX gomb
- Példák a JavaScript statikus módszerére