Introduzione al costruttore statico in Java
Un costruttore statico è il pezzo di codice utilizzato per inizializzare i dati statici, il che significa che una determinata attività deve essere eseguita una sola volta in tutto il programma. Di solito viene chiamato automaticamente prima che qualsiasi membro statico faccia riferimento o venga generata una prima istanza. Un costruttore statico è quello esplicitamente dichiarato utilizzando la parola chiave "statica". Un costruttore non può essere statico, astratto, finale, nativo, sincronizzato o strictfp in Java.
Hanno alcune caratteristiche uniche come segue:
- I parametri o i modificatori di accesso non sono presi da un costruttore statico.
- Una classe specifica può possedere un solo costruttore statico.
- L'ereditarietà o il sovraccarico non sono consentiti nei costruttori statici.
- Non può essere chiamato direttamente poiché viene sempre richiamato automaticamente.
- Se i valori di inizializzazione dei campi statici non vengono forniti, viene inizializzato sul valore predefinito come nella tabella Valori predefiniti.
Sintassi :
public class (
private ;
public static () ()
)
Qui stiamo provando a dichiarare un costruttore nella classe definendolo statico. Quando viene compilato un codice di questo tipo, viene visualizzato un messaggio di errore che indica che il modificatore illegale viene utilizzato per il costruttore nel tipo e sono consentiti solo pubblici, protetti e privati.
Funzionamento del costruttore statico in Java
I costruttori non possono essere statici in Java a causa del seguente motivo:
In Java, metodi e variabili statici si applicano alle classi. Ma un costruttore viene chiamato quando un nuovo operatore viene utilizzato per creare un'istanza. Poiché non appartiene alla classe di proprietà, non è consentito essere statico. Se nel caso in cui un costruttore sia considerato statico, non è possibile accedervi da un oggetto della sua sottoclasse.
Ma se un costruttore può essere statico, è possibile accedervi all'interno della classe ma non dalla sua sottoclasse. Inoltre, non può essere ereditato, il che significa che appartengono alla classe in cui sono dichiarati. Consentire un costruttore statico viola l'intero concetto di eredità, quindi è illegale.
Esempi di costruttore statico in Java
Possiamo comprendere meglio il concetto di costruttore statico in Java nei seguenti esempi:
Esempio 1
Codice:
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();
)
)
Produzione:
Qui stiamo ricevendo un errore di tempo di compilazione che ci dice che il modificatore statico non è consentito per il costruttore Employee () all'interno della classe Employee () poiché stiamo chiamando lo stesso creando un nuovo oggetto di seguito. Questo può essere risolto non dichiarandolo come statico. Guarda l'esempio qui sotto per lo stesso.
Esempio n. 2
Dobbiamo creare 2 classi all'interno dello stesso pacchetto; ParentExample.java e ChildExample.java che si estende dalla sua classe genitore.
Codice:
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();
)
)
Ora esegui ChildExample.java.
Produzione:
osservazioni:
- Entrambe le classi Parent e Child hanno costruttori predefiniti senza argomenti e un messaggio stampato per rendere chiaro il flusso di esecuzione.
- Il costruttore statico è il primo blocco di codice da eseguire nella classe poiché vengono eseguiti immediatamente all'avvio dell'esecuzione della rispettiva classe.
- La sottoclasse sovrascrive il metodo display message () e stampa il messaggio.
- Abbiamo creato un nuovo oggetto della classe ChildExample che esegue il primo costruttore di superclassi e quindi la seconda sottoclasse.
- Alla fine viene richiamato il metodo di visualizzazione dell'oggetto appena creato per visualizzare il messaggio.
- In tali casi in cui viene implementata l'ereditarietà, i costruttori vengono chiamati in modo esplicito o implicito. Quindi dovrebbe essere reso non statico in modo che sia accessibile.
- Quando viene creato statico, viene associato a una classe specifica rispetto alle sue istanze e quindi non sarà disponibile durante l'istanza dell'oggetto.
Esempio n. 3
In questo esempio, combineremo entrambi i costruttori statici e non statici di cui sopra e ne controlleremo l'implementazione.
Codice:
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();
)
)
Produzione:
Limitazioni del costruttore statico in Java
Ecco alcune limitazioni del costruttore statico in Java fornite di seguito:
- I nomi dei costruttori non possono essere espliciti e devono obbligatoriamente essere gli stessi del nome della classe. Poiché si limitano a queste convenzioni, non è possibile assegnare loro nomi più leggibili.
- Ogni volta che è necessario chiamare un costruttore, è necessario creare un nuovo oggetto. Ciò influisce anche sulle prestazioni del codice rendendolo così lento.
- I tipi restituiti di costruttori sono limitati per restituire lo stesso tipo di quello dell'oggetto.
- Non possiamo usare costruttori statici nella costruzione di sottoclassi poiché è consentita l'implementazione di soli costruttori di superclassi.
- Un costruttore statico non consente l'uso della parola chiave "this" per accedere a un'istanza.
- Gli sforzi di test richiesti sono più dove sono coinvolti costruttori statici.
Conclusione
Il lavoro principale di un costruttore è l'inizializzazione di un oggetto e, come visto da tutti gli esempi precedenti, non è possibile che un costruttore sia statico per il motivo per cui non è possibile accedere all'oggetto di una sottoclasse e ad altri membri non statici. L'alternativa al costruttore statico consiste nell'utilizzare blocchi statici di codice per inizializzare le variabili statiche di una classe.
Articoli consigliati
Questa è una guida al costruttore statico in Java. Qui discutiamo il funzionamento, i limiti e gli esempi di costruttori statici in Java in Java insieme alla loro implementazione. Puoi anche consultare i seguenti articoli per saperne di più–
- HashMap in Java
- JavaFX FileChooser
- JavaFX TextField
- Pulsante JavaFX
- Esempi di metodo statico JavaScript