Menu

Constructeurs privés, abstraits, de tableaux et de chaînes en Java

  • Principal
  • Autre
  • Constructeurs privés, abstraits, de tableaux et de chaînes en Java

private abstract array

Essayez Notre Instrument Pour Éliminer Les Problèmes

Ce didacticiel abordera les constructeurs spéciaux tels que le constructeur privé en Java, le résumé, la chaîne, le tableau, l'interface et le destructeur en Java:

Dans notre dernier tutoriel sur les constructeurs en Java, nous avons appris les concepts importants liés aux constructeurs en Java. Nous avons discuté de la manière de créer un constructeur et des règles pour définir les constructeurs, ainsi que des types de constructeurs, etc.

Nous avons également appris la surcharge du constructeur et le chaînage du constructeur. Maintenant, parlons de certains constructeurs spéciaux comme un constructeur privé, un constructeur abstrait et des constructeurs de chaînes et de tableaux en Java. Ensuite, nous discuterons des destructeurs en Java et enfin, nous explorerons les différences entre la méthode et les constructeurs.

=> Jetez un œil au guide du débutant Java ici.

Constructeurs privés et abstraits en Java

Commençons par un constructeur privé en Java.

meilleurs téléchargements de musique mp3 pour android

Ce que vous apprendrez:

Constructeur privé en Java

Comme déjà mentionné, les constructeurs de la classe Java peuvent avoir des spécificateurs d'accès associés. Par conséquent, nous pouvons avoir des constructeurs privés ou publics. Nous discuterons plus en détail des spécificateurs d'accès dans nos didacticiels suivants et nous revisiterons également les constructeurs.

Lorsque le constructeur est déclaré privé, il n'est alors accessible qu'à l'intérieur de la classe. Il ne peut pas accéder aux classes dérivées via une autre classe. Par conséquent, nous devons fournir une méthode publique dans la classe qui a des constructeurs privés afin que cette méthode publique puisse accéder aux constructeurs privés.

En Java, le constructeur privé peut être utilisé dans les situations suivantes:

  • Pour implémenter des singletons.
  • Pour incorporer les méthodes d'usine.
  • Pour les classes qui n'ont que des membres statiques (variables et méthodes).
  • Pour les classes ayant des membres finaux. (constantes - finales et statiques).
  • Pour utiliser des énumérations de type sécurisé.

Par exemple , prenons un cours de singleton. Une classe singleton est une classe qui n'autorise qu'un seul objet à la fois. Nous pouvons utiliser le constructeur privé pour nous assurer que nous n'autorisons pas la création de plus d'un objet.

Le programme ci-dessous implémente une classe singleton à l'aide d'un constructeur privé.

class SingleTonClass { //Static Class Reference private static SingleTonClass obj=null; private SingleTonClass(){ System.out.println('SingleTonClass::Private constructor'); } public static SingleTonClass create_object(){ //logic to create only one instance if(obj==null){ obj= new SingleTonClass(); } return obj; } public void display(){ System.out.println('This is SingleTonClass !!'); } } class Main { public static void main(String args()){ //cannot call private constructor directly. SingleTonClass myobject= SingleTonClass.create_object(); myobject.display(); } }

Production:

Constructeur privé en Java

Le programme ci-dessus déclare une classe singleton. Nous avons fourni un constructeur privé et une méthode publique pour accéder au constructeur privé et aussi pour limiter le nombre d'objets à un seul. Dans la méthode main, nous exécutons la méthode publique pour créer un objet de classe singleton.

Constructeur de classe abstraite en Java

Classe abstraite en Java comme C ++ sauf que contrairement au C ++, nous avons un mot-clé abstrait en Java utilisé pour déclarer une classe abstraite. Les classes abstraites en Java peuvent avoir des constructeurs. Ce constructeur de classe abstraite est appelé lorsque nous créons une instance d'une classe d'implémentation (qui hérite d'une classe abstraite).

Prenons l'exemple suivant d'un constructeur de classe abstraite.

//abstract class declaration abstract class BaseClass { BaseClass() { System.out.println('BaseClass::Constructor Called'); } abstract void func1(); } class DerivedClass extends BaseClass { DerivedClass() { System.out.println('DerivedClass::Constructor Called'); } void func1() { System.out.println('DerivedClass::func1() called'); } } class Main { public static void main(String args()) { DerivedClass d = new DerivedClass(); } }

Production:

Constructeur de classe abstraite en Java - sortie

Comme une classe abstraite ne peut pas être instanciée, nous héritons d'une nouvelle classe de cette classe abstraite. La sortie du programme montre que lorsque nous créons un objet de la classe dérivée dans la méthode main, le constructeur de la classe abstraite est appelé en premier, suivi d'un constructeur de classe dérivée.

Constructeur d'interface en Java

Les interfaces en Java sont similaires aux classes abstraites. Les interfaces sont par défaut un résumé public et n'ont que des prototypes de méthode. Ces prototypes sont ensuite implémentés dans la classe qui implémente l'interface.

Alors, les constructeurs sont-ils présents dans les interfaces?

Non. Les interfaces n'ont pas de constructeur. En effet, les méthodes d'une interface ne sont que des prototypes et par conséquent nous n'avons pas besoin d'instancier ou de créer un objet de l'interface car nous n'allons pas l'utiliser du tout. Il n'est donc pas non plus nécessaire d'avoir un constructeur dans l'interface.

Le programme Java ci-dessous illustre cette logique.

//interface declaration interface Interface_Add{ public int addNumbers(int num1, int num2); //method prototype } class AddClass implements Interface_Add{ public int addNumbers(int num1, int num2){ //method implementation int result= num1+num2; return result; } } class Main{ public static void main(String args()) { AddClass obj= new AddClass(); System.out.println('Result of addition:' + obj.addNumbers(2, 3)); } }

Production:

Constructeur d

Ici, nous avons une interface «Interface_add» avec une méthode prototype «addNumbers». Ensuite, une classe 'AddClass' implémente cette interface ainsi que la méthode addNumbers.

Dans la méthode main, la classe est instanciée et la méthode est exécutée. Par conséquent, nous ne voyons aucun besoin de constructeur dans cette interface.

Voyons maintenant les constructeurs de certaines classes préexistantes dans String et Array de type Java.

Constructeur de chaîne en Java

Un objet chaîne en Java peut être défini comme un objet de la classe String. La classe String fournit les constructeurs suivants pour créer et initialiser des objets String.

Certains de ces constructeurs sont décrits ci-dessous:

# 1) Chaîne (octet () myArray)

Construit un nouvel objet String à partir d'un tableau d'octets donné. Pour construire l'objet chaîne, il utilise le jeu de caractères de plate-forme par défaut et décode le tableau d'octets.

Exemple:

byte() myArray = {65, 66, 67, 68, 69}; String str =new String(myArray); //ABCDE

# 2) Chaîne (byte () myArray, Charset char_set)

Ce constructeur construit un nouvel objet chaîne en utilisant char_set spécifié dans l'appel du constructeur pour décoder le tableau d'octets.

Exemple:

byte() myArray = {65, 66, 67, 68, 69}; Charset cs = Charset.defaultCharset(); String str = new String(myArray, cs); //ABCDE

# 3) Chaîne (char () myArray)

Nous pouvons construire un objet String à partir d'un tableau de caractères.

Exemple:

char myArray() = {'P', 'a', 'r', 'i', 's'}; String s = new String(myArray); //Paris

# 4) Chaîne (char () myArray, int start_index, int count)

Ici, nous construisons un objet String à partir d'un tableau de caractères en incluant le nombre de caractères de start_index jusqu'au nombre.

Exemple:

char myArray() = {'P', 'a', 'r', 'i', 's'}; String s = new String(myArray, 0,2); //Pa

# 5) Chaîne (int () intArray, int offset, int count)

Le constructeur ci-dessus alloue un nouvel objet String à partir d'un tableau int. Le nombre de caractères de la chaîne est défini par offset et count.

meilleure idée de python pour windows 10

Exemple:

int() intArray = {65, 69,73,79,85 }; String s = new String (intArray, 0, 5); //AEIOU

# 6) Chaîne (StringBuffer strbuffer)

Dans ce constructeur, un nouvel objet String est construit à partir d'un objet StringBuffer.

Exemple:

StringBuffer strbuffer = new StringBuffer('SoftwareTestingHelp'); String s = new String (strbuffer); //SoftwareTestingHelp

# 7) Chaîne (StringBuilder strbuilder)

Un nouvel objet String est créé à l'aide de l'objet StringBuilder.

Exemple:

logiciel gratuit pour ripper des dvd en mp4
StringBuilder strbuilder = new StringBuilder('SoftwareTestingHelp'); String s = new String(strbuilder); // SoftwareTestingHelp

Constructeurs de tableaux en Java

Les tableaux utilisent des constructeurs pour créer et initialiser des tableaux à l'aide d'un nouveau mot clé comme indiqué ci-dessous.

int() data = new int(4);

L'instruction ci-dessus initialise un tableau de 4 éléments à la valeur par défaut 0.

Une autre façon d'initialiser le tableau est donnée ci-dessous:

int() data = new int(){2, 4, 6, 8};

Destructor en Java

Jusqu'à présent, nous avons vu des constructeurs en Java à l'aide desquels nous créons un objet. Lorsque l'objet a terminé son travail et n'est plus nécessaire, la mémoire allouée à l'objet doit être libérée ou désallouée. C'est le travail d'un destructeur en Java.

En Java, le garbage collector est chargé de libérer les objets qui ne sont plus utilisés ou qui sont devenus inaccessibles. Les destructeurs en Java sont appelés finaliseurs et ils ne sont pas déterministes, de sorte que nous ne pouvons pas garantir qu'ils seront exécutés.

En Java, nous n'avons pas à nous soucier des destructeurs. Les destructeurs n'ont pas de syntaxe spécifique en Java. Les objets sont détruits mais nous n'appelons pas destructor comme nous l'appelons en C ++.

Comme mentionné ci-dessus, le travail du destructeur est effectué par le finaliseur qui est appelé par le garbage collector.

La méthode du finaliseur en Java est illustrée ci-dessous pour votre référence.

class Main { public static void main(String() args) { Main dm = new Main(); //create object dm = null; System.gc(); //call garbage collector System.out.println('Main Mathod'); } protected void finalize() //finalize method { System.out.println('Finalize method :: object is garbage collected'); } }

Production:

Destructor en Java

Dans le programme ci-dessus, nous créons un objet de classe. Définissez-le sur null, puis nous appelons la méthode System.gc (). Maintenant, cet objet est inaccessible et la méthode finalize (destructor) est appelée implicitement.

Méthode Constructor Vs en Java

Faisons un tableau de certaines des différences entre un constructeur et une méthode en Java.

ConstructeursMéthode
Crée un nouvel objet.Fonctionne sur un objet déjà existant.
Un bloc de code utilisé pour initialiser les membres de la classe lors de la création d'un objet.Une collection d'instructions de programmation qui génèrent un résultat lors de l'exécution.
Utilisé pour effectuer l'initialisation des objets.Une séquence d'instructions exécutées par Java. Peut contenir ou non une routine d'initialisation.
Appelé implicitement.Doit être invoqué explicitement dans un programme.
Appelé lorsqu'un nouvel objet est créé à l'aide du mot-clé new.Appelé lorsque la méthode est appelée par le programmeur.
A le même nom que celui d'une classe.Il peut avoir n'importe quel nom autorisé par le langage de programmation.
N'a pas de type de retour.Doit avoir un type de retour, sinon il doit retourner void.
Une classe peut avoir de nombreux constructeurs surchargés.La classe peut avoir des méthodes surchargées ainsi que des méthodes distinctes.
Il ne peut pas être hérité par la classe enfant.Il peut être hérité par la classe enfant et même remplacé.

Questions fréquemment posées

Q # 1) Les constructeurs peuvent-ils être privés?

Répondre: Oui. Les constructeurs en Java peuvent être privés. Toutes les classes, y compris les classes abstraites, peuvent avoir des constructeurs privés. En utilisant des constructeurs privés, nous pouvons empêcher la classe d'être instanciée ou nous pouvons limiter le nombre d'objets de cette classe.

Q # 2) Quelle est l'utilisation du constructeur de classes abstraites en Java?

Répondre: Un constructeur de classe abstraite est appelé lorsque nous créons un objet de la classe dérivée qui hérite de la classe abstraite. De plus, si la classe abstraite a des variables membres, nous pouvons les initialiser dans le constructeur de classe abstraite.

Q # 3) Pouvons-nous définir un constructeur paramétré dans une classe abstraite en Java?

Répondre: Oui, nous pouvons avoir un constructeur paramétré dans une classe abstraite. Ensuite, nous pouvons appeler ce constructeur à partir de la classe dérivée qui a hérité de la classe abstraite en utilisant l'appel super ().

Q # 4) Savez-vous pourquoi il n'y a pas de destructeur en Java?

Répondre: Java n'a pas besoin d'avoir un destructeur spécifique car il a son garbage collector. Ce garbage collector détruit les objets inaccessibles et libère la mémoire. Une méthode nommée finaliser fait également partie du ramasse-miettes qui s'exécute de manière non déterministe et remplit la fonction de destructeur comme la libération des ressources, etc.

Q # 5) La classe abstraite peut-elle avoir un corps?

Répondre: Non. Une classe abstraite ne peut avoir que des déclarations de méthode et des constructeurs. Ses méthodes ne sont pas implémentées. La classe qui hérite de cette classe abstraite implémente les méthodes. Outre le prototype ou les déclarations, il peut également avoir une visibilité ou accéder à des spécificateurs.

Conclusion

Ceci complète notre tutoriel sur les constructeurs en Java. Ici, nous avons couvert la définition, la création et les types de constructeurs. Nous avons également discuté de la surcharge des constructeurs et du chaînage des constructeurs en Java.

Nous avons exploré les constructeurs abstraits et privés en Java et appris pourquoi les interfaces ne peuvent pas avoir de constructeurs. Nous avons vu des constructeurs qui sont utilisés dans les classes array et String.

Nous avons également discuté des destructeurs en Java qui exécutent la fonction opposée à celle des constructeurs. Les constructeurs créent des objets tandis que les destructeurs détruisent des objets. En Java, la fonction de destructeur est exécutée par le finaliseur qui est exécuté pendant le garbage collection.

Ainsi, nous n'avons pas de destructeur spécifique en Java et nous n'avons pas besoin de le définir comme nous le faisons en C ++. Nous avons également discuté des différences entre la méthode et le constructeur. Nous savons que le constructeur n'est pas la même chose qu'une méthode, mais nous pouvons voir le constructeur comme une méthode spéciale.

=> Lisez la série de formations Easy Java.

lecture recommandée

^