Comment créer constructeurs en java

UN constructeur

est un bloc de code qui est appelé quand une instance d'un objet est créé en Java. À bien des égards, un constructeur est similaire à une méthode, mais quelques différences existent:

• Un constructeur ne possède pas un type de retour.

• Le nom du constructeur doit être le même que le nom de la classe.

• Contrairement aux méthodes, les constructeurs ne sont pas considérés comme des membres d'une classe. (Cela est important que quand il vient à la succession.)

• Un constructeur est appelé quand une nouvelle instance d'un objet est créé. En fait, il est le nouveau mot-clé qui appelle le constructeur. Après la création de l'objet, vous ne pouvez pas appeler à nouveau le constructeur.

Voici le format de base pour coder un constructeur:

public Nom de la classe (paramètre-liste) [Lancers exception ...] {déclarations ...}

Le mot-clé public indique que d'autres classes peuvent accéder au constructeur. Voilà ce que vous désirez, mais vous voudrez peut-être créer un constructeur privé. Nom de la classe doit être le même que le nom de la classe qui contient le constructeur. Vous codez la liste des paramètres de la même façon que vous codez pour une méthode.

Notez également qu'un constructeur peut lever des exceptions si elle rencontre des situations qu'il ne peut pas récupérer.

Création constructeurs de base

Probablement la raison la plus courante pour le codage d'un constructeur est de fournir des valeurs initiales pour les champs de classe lorsque vous créez l'objet. Supposons que vous avez un acteur du nom de classe qui a champs nommés prenom et nom. Vous pouvez créer un constructeur de la classe Acteur:

Acteur public (Chaîne d'abord, String dernière) {prenom = première lastName = Last-}

Ensuite, vous créez une instance de la classe Acteur en appelant ce constructeur:

Acteur d'un nouvel acteur = ("Arnold", "Schwarzenegger") -

Un nouvel objet acteur pour Arnold Schwarzenegger est créé.

Comme les méthodes, les constructeurs peuvent être surchargés. En d'autres termes, vous pouvez fournir plus d'un constructeur pour une classe, à condition que chaque constructeur a une signature unique. Voici un autre constructeur de la classe Acteur:

Acteur public (Chaîne d'abord, String dernière, bonne Boolean) {prenom = première lastName = dernière goodActor = goodwill}

Ce constructeur vous permet de créer un objet Acteur de l'information en plus le nom de l'acteur:

Acteur d'un nouvel acteur = ("Arnold", "Schwarzenegger", false) -

Création des constructeurs par défaut

Chaque classe dispose d'un droit à un constructeur. Si vous ne fournissez pas un constructeur, Java nomme un pour vous, gratuitement. Ce constructeur est appelé le libre constructeur par défaut. Il n'a pas d'accepter tous les paramètres et ne pas faire quelque chose, mais il ne permet votre classe à instancier.

Ainsi, les deux classes suivantes sont identiques:

publique Class1 {de Class1 publique () {}} de Class1 publique {}

Dans le premier exemple, la classe déclare explicitement un constructeur qui n'a pas accepter tous les paramètres et n'a pas de déclarations dans son corps. Dans le deuxième exemple, Java crée un constructeur par défaut qui fonctionne exactement comme le constructeur montré dans le premier exemple.

Le constructeur par défaut est pas créé si vous déclarez des constructeurs pour la classe. En conséquence, si vous déclarez un constructeur qui accepte les paramètres et voulez toujours avoir un constructeur vide (sans paramètres et pas de corps), vous devez déclarer explicitement un constructeur vide pour la classe.

Un exemple pourrait effacer ce point haut. Le code suivant fait pas compiler:

public class BadActorApp {static void main (String [] args) {Acteur publics a = new Acteur () - // erreur: ne compilera pas}} {String classe Acteur privé lastName-private String prenom-privé booléen goodActor-publique Acteur (String dernière, Chaîne d'abord) {lastName = dernière prenom = Prénom} Acteur publique (String dernière, Chaîne d'abord, bonne Boolean) {lastName = dernière prenom = première goodActor = goodwill}}

Ce programme ne compilera pas car il ne prévoit pas explicitement un constructeur par défaut pour l'Acteur de classe parce qu'elle ne fournit d'autres constructeurs, le constructeur par défaut est pas généré automatiquement.

Appel d'autres constructeurs

Un constructeur peut appeler un autre constructeur de la même classe en utilisant le mot-clé spécial cela comme un appel de méthode. Cette technique est couramment utilisé lorsque vous avez plusieurs constructeurs qui misent sur l'autre.

Considérez cette classe:

classe publique Acteur {private String goodActor-publique Acteur lastName-private String prenom-privé booléenne (String dernière, Chaîne d'abord) {lastName = dernière prenom = Prénom} Acteur publique (String dernière, Chaîne d'abord, bonne Boolean) {ce ( nom, prénom) -goodActor = goodwill}}

Voici le deuxième constructeur appelle le premier constructeur à mettre les champs nom et prénom. Ensuite, il définit le champ goodActor.

Vous avez un peu de restrictions dans l'utilisation du mot-clé this comme un appel du constructeur:

• Vous pouvez appeler un autre constructeur que dans la première déclaration d'un constructeur. Ainsi, le code suivant ne compilera pas:

   Acteur publique (String dernière, Chaîne d'abord, bonne booléen) {goodActor = goodwillce (nom, prénom) -  // Erreur: ne compilera}

  Si vous essayez de compiler une classe avec ce constructeur, vous obtenez un message disant appel à cette première déclaration doit être dans le constructeur.

• Chaque constructeur peut appeler un seul autre constructeur, mais vous pouvez les constructeurs de la chaîne. Si une classe a trois constructeurs, le premier constructeur peut appeler la seconde, qui à son tour appelle la troisième.

• Vous ne pouvez pas créer des boucles dans lequel les constructeurs appellent les uns les autres. Voici une classe qui ne compilera pas:

  classe CrazyClass{ Chaîne privée firstString- Chaîne privée secondString- CrazyClass publique (String première, seconde chaîne) { cette (première) - secondString = deuxième } CrazyClass publique (Chaîne d'abord) { cette (première, "default") - // erreur: ne sera pas // Compile }}

  Le premier constructeur commence par appeler la deuxième constructeur, qui appelle le premier constructeur. Le compilateur se plaint que cette erreur est un constructeur appel récursif et refuse de compiler la classe poliment.

Si vous ne l'appelez pas explicitement un constructeur dans la première ligne d'un constructeur, Java insère du code qui appelle automatiquement le constructeur par défaut de la classe de base - qui est, la classe que cette classe hérite.