Introduction à Static Constructor en Java

Un constructeur statique est le morceau de code utilisé pour initialiser des données statiques, ce qui signifie qu'une tâche particulière ne doit être exécutée qu'une seule fois tout au long du programme. Il est généralement appelé automatiquement avant tout membre statique référencé ou une première instance est générée. Un constructeur statique est celui qui est explicitement déclaré à l'aide du mot clé "statique". Un constructeur n'est pas autorisé à être statique, abstrait, final, natif, synchronisé ou strictfp en Java.

Ils ont quelques caractéristiques uniques comme suit:

  • Les paramètres ou les modificateurs d'accès ne sont pas pris par un constructeur statique.
  • Une classe spécifique ne peut posséder qu'un seul constructeur statique.
  • L'héritage ou la surcharge n'est pas autorisé dans les constructeurs statiques.
  • Il ne peut pas être appelé directement car il est toujours appelé automatiquement.
  • Si les valeurs d'initialisation des champs statiques ne sont pas fournies, il s'initialise à leur valeur par défaut comme dans le tableau des valeurs par défaut.

Syntaxe :

public class (
private ;
public static () ()
)

Ici, nous essayons de déclarer un constructeur dans la classe en le définissant comme statique. Lorsqu'un tel code est compilé, nous obtenons un message d'erreur indiquant que le modificateur illégal est utilisé pour le constructeur de type et que seuls public, protected et private sont autorisés.

Fonctionnement du constructeur statique en Java

Les constructeurs ne sont pas autorisés à être statiques en Java pour la raison suivante:

En Java, les méthodes et variables statiques s'appliquent aux classes. Mais un constructeur est appelé lorsqu'un nouvel opérateur est utilisé pour créer une instance. Comme il n'appartient pas à la classe de propriétés, il n'est pas autorisé à être statique. Si dans le cas où un constructeur est considéré comme statique, il ne peut pas être consulté par un objet de sa sous-classe.

Mais si un constructeur est autorisé à être statique, il est accessible à l'intérieur de la classe, mais pas par sa sous-classe. Il ne peut pas non plus être hérité, ce qui signifie qu'ils appartiennent à la classe où ils sont déclarés. Autoriser un constructeur statique enfreint le concept entier de l'héritage donc il est illégal.

Exemples de constructeur statique en Java

Nous pouvons mieux comprendre le concept de constructeur statique en Java dans les exemples suivants:

Exemple 1

Code:

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();
)
)

Production:

Ici, nous obtenons une erreur de temps de compilation nous disant que le modificateur statique n'est pas autorisé pour le constructeur Employee () dans la classe Employee () car nous l'appelons en créant un nouvel objet ci-dessous. Cela peut être résolu en ne le déclarant pas comme statique. Consultez l'exemple ci-dessous pour la même chose.

Exemple # 2

Nous devons créer 2 classes dans le même package; ParentExample.java et ChildExample.java qui s'étend de sa classe parente.

Code:

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();
)
)

Exécutez maintenant ChildExample.java.

Production:

Observations:

  • Les classes Parent et Child ont des constructeurs par défaut sans arguments et un message imprimé pour rendre le flux d'exécution clair.
  • Le constructeur statique est le premier bloc de code à exécuter dans la classe car ils sont exécutés immédiatement au démarrage de l'exécution de la classe respective.
  • La sous-classe remplace la méthode display message () et imprime le message.
  • Nous avons créé un nouvel objet de la classe ChildExample qui exécute le premier constructeur de superclasse puis la deuxième sous-classe.
  • Enfin, la méthode d'affichage de l'objet nouvellement créé est invoquée pour afficher le message.
  • Dans de tels cas où l'héritage est implémenté, les constructeurs sont appelés explicitement ou implicitement. Il doit donc être rendu non statique pour être accessible.
  • Quand elle devient statique, elle est associée à une classe spécifique à ses instances et ne sera donc pas disponible pendant l'instanciation d'objet.

Exemple # 3

Dans cet exemple, nous allons combiner les constructeurs statiques et non statiques ci-dessus et vérifier son implémentation.

Code:

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();
)
)

Production:

Limitations de Static Constructor en Java

Voici quelques limitations du constructeur statique en java ci-dessous:

  • Les noms de constructeur ne peuvent pas être explicites et doivent obligatoirement être les mêmes que le nom de classe. Puisqu'ils sont confinés à ces conventions, des noms plus lisibles ne peuvent pas leur être donnés.
  • Chaque fois qu'un constructeur doit être appelé, un nouvel objet doit être créé. Cela affecte également les performances du code, ce qui le rend lent.
  • Les types de retour des constructeurs sont limités pour retourner le même type que celui de l'objet.
  • Nous ne pouvons pas utiliser de constructeurs statiques dans la construction de sous-classes car l'implémentation de seuls constructeurs de superclasses est autorisée.
  • Un constructeur statique ne permet pas l'utilisation du mot-clé «this» pour accéder à une instance.
  • Les efforts de test requis concernent davantage les constructeurs statiques.

Conclusion

Le travail principal d'un constructeur consiste à initialiser un objet et, comme le montrent tous les exemples ci-dessus, un constructeur n'est pas autorisé à être statique pour la principale raison que l'objet d'une sous-classe et d'autres membres non statiques ne sont pas accessibles par lui. L'alternative au constructeur statique consiste à utiliser des blocs de code statiques pour initialiser les variables statiques d'une classe.

Articles recommandés

Ceci est un guide de Static Constructor en Java. Nous discutons ici du fonctionnement, des limitations et des exemples de constructeurs statiques en java en java ainsi que leur implémentation. Vous pouvez également consulter les articles suivants pour en savoir plus–

  1. HashMap en Java
  2. JavaFX FileChooser
  3. JavaFX TextField
  4. Bouton JavaFX
  5. Exemples de méthode statique JavaScript

Catégorie:

Développement de logiciels