Comment implémenter un constructeur privé en Java

Cet article vous fournira une connaissance détaillée et complète de Private Constructor en Java et son utilisation avec des exemples.

Constructeurs sont utilisés pour initialiser l'état d'un objet. Semblable aux méthodes, un constructeur peut également contenir une collection d'instructions, qui ne peuvent être appelées que des instructions. Dans cet article, nous aborderons le constructeur privé dans dans l'ordre suivant:



Introduction au constructeur en Java

Les constructeurs sont exécutés au moment de la création de l'objet. Pour mieux comprendre le constructeur et ses applications, pensez simplement à une boîte comme à une classe. Une classe Box est supposée avoir certaines variables de classe (c'est-à-dire longueur, largeur et hauteur). Cependant, au moment de la création de son objet (c'est-à-dire que la boîte existe dans la mémoire de l'ordinateur), une boîte peut exister sans aucune valeur définie pour ses quantités dimensionnelles.



Evidemment non.

Par conséquent, un constructeur est introduit pour affecter des valeurs aux variables de classe lors de la création de l'objet. Cela peut être fait explicitement par le programmeur ou par Java lui-même. Lorsqu'il est fait par Java lui-même, il est appelé constructeur par défaut.



Il est impératif de comprendre que toute méthode, qui possède un spécificateur d'accès fourni par le codeur au constructeur, qui est rendue privée, ne peut être accédée qu'à l'intérieur de la classe elle-même.

Constructeur privé à Java

Classe Singleton

À partir du nom lui-même, nous pouvons appeler une classe un singleton si elle limite le nombre d'objets de cette classe à un. Une classe ne peut pas avoir plus d'un seul objet dans de tels cas. Les classes singleton sont utilisées de manière exhaustive dans des concepts tels que la mise en réseau et la connectivité de base de données. La classe Singleton est un cours privé .



Il doit y avoir un autre moyen d'extraire l'instance de la classe et une méthode de retour pour récupérer le résultat. Voici une illustration appropriée de la même chose. Le premier pictogramme représente le résultat probable où la valeur de «a.x» équivaut à 20 et la valeur de «b.x» donne également 20. Dans le code, alors que nous définissons la classe privée singleton, les constructeurs de celle-ci ne sont pas accessibles en dehors de la classe.

Valeur de a.x = 20

Valeur de b.x = 20

// Programme Java pour illustrer l'implémentation de Singleton // modèle à l'aide de constructeurs privés. import java.io. * class MySingleton {instance MySingleton statique = null public int x = 10 // le constructeur privé n'est pas accessible en dehors de la classe private MySingleton () {} // Méthode Factory pour fournir aux utilisateurs des instances static public MySingleton getInstance () {if (instance == null) instance = new MySingleton () return instance}} // Classe de pilote classe Main {public static void main (String args []) {MySingleton a = MySingleton.getInstance () MySingleton b = MySingleton.getInstance () ax = ax + 10 System.out.println ('Valeur de ax =' + ax) System.out.println ('Valeur de bx =' + bx)}}

Impact du constructeur privé en Java

Les constructeurs privés ne peuvent pas accéder aux classes dérivées d'une autre classe. Ainsi, nous devons donner une fonction publique, qui appelle le constructeur privé. Dans le cas où l'objet n'est pas initialisé, ou nous devons renvoyer une instance à l'objet s'il a été initialisé. Ceci est particulièrement utile pour les objets qui ne peuvent pas être initialisés. Un constructeur privé est utilisé dans les cas suivants:

  • Les classes respectives, qui n'ont que des méthodes et des membres statiques.
  • Les classes spécifiques, qui n'ont que des membres finaux statiques largement utilisés (constantes).
  • Pour incorporer des singletons.
  • Incorporer les méthodes d'usine.

Pour utiliser des énumérations, qui sont de type sécurisé.

Chaîne de constructeur interne

Le chaînage de constructeur interne se produit lorsqu'un constructeur appelle un autre constructeur de la même classe, il peut alors être appelé chaînage de constructeur. Il est de notre devoir d'utiliser ce mot-clé pour appeler un autre constructeur de la classe. Dans certains cas, il est utilisé pour définir certaines valeurs par défaut des variables de classe. Gardez également à l'esprit qu'un autre appel de constructeur doit être la première instruction du bloc de code.

De plus, il ne devrait pas y avoir d'appels récursifs, ce qui créera une boucle infinie. Voyons maintenant un exemple de chaînage de constructeur dans un programme java.

package com.journaldev.constructor public class Employee {private int id private String name public Employee () {this ('John Doe', 999) System.out.println ('Default Employee Created')} public Employee (int i) { this ('John Doe', i) System.out.println ('Employee Created with Default Name')} public Employee (String s, int i) {this.id = i this.name = s System.out.println ( 'Employé Créé')} public static void main (String [] args) {Employé emp = nouvel employé () System.out.println (emp) Employé emp1 = nouvel employé (10) System.out.println (emp1) Employé emp2 = new Employee ('Pankaj', 20) System.out.println (emp2)} @Override public String toString () {return 'ID =' + id + ', Name =' + name} public int getId () {return id } public void setId (int id) {this.id = id} public String getName () {return name} public void setName (String name) {this.name = name}}

Modèle de conception de classe Singleton

  • Membre de niveau classe (méthode d'initialisation avide):

  1. Tout d'abord, créez une instance statique constante privée d'une classe singleton.

  2. Ensuite, écrivez une méthode statique, qui retourne l'objet d'une classe singleton, que nous avons créée en tant qu'instance de membre de classe.

  3. Il est possible de marquer un membre statique comme public pour accéder directement à une instance statique constante.

  4. La classe singleton diffère d'une classe Java normale en termes d'instanciation. Dans une classe normale, un constructeur est utilisé mais pour la classe singleton, nous utilisons la méthode get Instance ().

    keyerror: 'a'
  • Membre de niveau classe (méthode d'initialisation paresseuse):

  1. Tout d'abord, lancez un constructeur comme privé.

  2. Créez ensuite une instance statique privée de cette classe singleton. Gardez à l'esprit de NE PAS l'instancier.

  3. Ensuite, écrivez une méthode statique, qui vérifie la valeur null du membre d'instance statique et lance l'instance. Enfin, il renvoie un objet de la classe singleton.

  • Le membre au niveau de la classe (initialisation paresseuse avec méthode de double verrouillage):

Considérez deux threads en cours d'exécution où les deux entrent simultanément dans l'instruction «if» alors que l'instance est nulle. Où, un thread entre dans un bloc synchronisé pour créer une instance, tandis que l'autre est bloqué. Comme le premier thread réside dans le bloc synchronisé, le thread dans la file d'attente crée un autre objet singleton. Veuillez noter que lorsque le deuxième thread entre dans un bloc synchronisé, il ne parvient pas à vérifier si l'instance est non nulle.

  • Utilisation de la classe Inner imbriquée (méthode Lazy Load):

Ici, il est basé sur les spécifications du langage Java (JLS). La machine virtuelle Java charge les membres de données statiques uniquement à la demande. Ainsi, la classe Singleton se charge d'abord par la JVM. Par conséquent, il n'y a pas de membre de données statique dans une classe

Le titulaire de classe Singleton ne charge pas SINGLE_INSTANCE. Lorsque nous appelons la méthode getIntance, cela se produit uniquement. JLS garantit l'exécution de l'initialisation de la classe. Une disposition pour la synchronisation explicite sur la méthode statique getInstance () pour le chargement et l'initialisation. Comme l'initialisation crée la variable statique SINGLE_INSTANCE de manière séquentielle, toutes les invocations simultanées de getInstance () reviendront de la même manière sans surcharge de synchronisation.

  • En utilisant Enums

Toutes les approches ci-dessus ne sont pas des solutions complètes dans tous les cas. Plusieurs instances des implémentations ci-dessus peuvent être créées à l'aide de la réflexion. Dans les deux scénarios, nous pouvons contourner le constructeur privé et créer plusieurs instances. Par conséquent, une nouvelle approche consiste à créer une classe singleton à l'aide d'énumérations. Comme les champs enums sont des constantes de temps compilées, ce sont des instances de leur type enum. Ils sont construits lorsque le type enum est référencé pour la première fois.

Avec cela, nous arrivons à la fin de l'article Private Constructor in Java. J'espère que vous avez compris les constructeurs privés et comment ils peuvent être utilisés en Java.

Vérifiez par Edureka, une entreprise d'apprentissage en ligne de confiance avec un réseau de plus de 250 000 apprenants satisfaits répartis dans le monde entier. Le cours de formation et de certification Java J2EE et SOA d'Edureka est conçu pour les étudiants et les professionnels qui souhaitent devenir développeur Java. Le cours est conçu pour vous donner une longueur d'avance dans la programmation Java et vous former aux concepts Java de base et avancés ainsi qu'à divers frameworks Java tels que Hibernate & Spring.

Vous avez une question pour nous? Veuillez le mentionner dans la section commentaires de ce blog «Tutoriel Java» et nous vous répondrons dans les plus brefs délais.