web-dev-qa-db-fra.com

Quand appeler le constructeur et quand appeler la méthode en Java?

J'ai du mal à comprendre parfaitement l'utilisation des constructeurs en Java.

Ce que j'ai appris jusqu'à présent sur les constructeurs est ce qui suit:

  • même nom que la classe
  • abréviation CTOR
  • surcharge
  • pas de type de retour
  • créer un objet d'une classe
  • chaque classe a un constructeur par défaut

Lorsque, par exemple, une chaîne doit être renvoyée d'une classe à laquelle doit être appelée, une méthode pourrait être créée, c'est-à-dire un constructeur ne suffira pas car cela ne retournera rien.

tentative de répondre à la question

Afin d'expliquer ce que je veux dire, j'ai créé une classe avec deux constructeurs et deux méthodes qui renvoient une chaîne.

public class HelloWorldConstructor {
    public HelloWorldConstructor() { }

    public HelloWorldConstructor(String a) {
        saySomething(a);
    }

    public HelloWorldConstructor(String a, String b) {
        saySomething(a, b);
    }

    void saySomething(String a) {
        System.out.println(a);
    }

    void saySomething(String a, String b) {
        System.out.println(a + ", " + b);
    }
}

Option 1

Il est possible de renvoyer une chaîne en appelant la méthode qui réside dans la classe.

public class CallConstructor {
    public static void main(String[] args) {
        HelloWorldConstructor hwc = new HelloWorldConstructor();

        hwc.saySomething("allo");
        hwc.saySomething("allo", "allo");
    }
}

retour:

allo
allo, allo

Option 2

Il est également possible de renvoyer une chaîne en appelant directement le constructeur.

public class CallConstructor2 {
    public static void main(String[] args) {
        new HelloWorldConstructor("allo");
        new HelloWorldConstructor("allo", "allo");
    }
}

retourne la même chose que l'option 1.

Discussion

Lorsque l'option 2 est choisie, deux objets doivent être créés au lieu d'une comme illustré par l'option 1, mais quand choisir l'option 2 et lorsque l'option 1? Dans ce cas, je pense qu'il est préférable de choisir l'option 1 comme un objet sera créé, mais l'option 2 pourrait être adaptée lorsque d'autres circonstances sont applicables.

tilisation des constructeurs en Java

Le constructeur de l'exemple donne simplement une valeur initiale aux membres de la classe.

https://stackoverflow.com/a/19941847/2777965

Les constructeurs sont utilisés pour initialiser les instances de vos classes. Vous utilisez un constructeur pour créer de nouveaux objets souvent avec des paramètres spécifiant l'état initial ou d'autres informations importantes sur l'objet.

Après avoir lu sur la théorie et le Q & en tant que constructeurs, j'ai du mal à les comprendre. Je sais comment appeler un constructeur et comment appeler une méthode, mais je ne peux pas rationaliser cela.

  • Un constructeur doit être appelé directement quand ...
  • La surcharge du constructeur sera effectuée quand ...
  • Les méthodes seront appelées directement en appelant le constructeur par défaut lorsque ...
javamethodsconstructors
2
030

Vous appelez un constructeur lorsque vous souhaitez créer une nouvelle instance d'objet. Par exemple, si vous avez une classe Button, vous appelez le constructeur si vous souhaitez créer une nouvelle instance Button.

Si vous n'avez pas besoin d'un nouvel objet, n'utilisez pas de constructeur. Dans votre exemple, vous utilisez simplement le constructeur de manière convoluée d'appeler une méthode, mais vous n'utilisez pas réellement l'objet créé (résultat de l'expression new- expression) pour quoi que ce soit. C'est une indication claire que vous n'avez pas besoin d'appeler un constructeur. Si vous avez fait saySomething statique, vous n'avez pas besoin d'appeler des constructeurs.

La raison de votre confusion est probablement que la classe HelloWorldConstructor n'a pas vraiment d'objet au-delà de la production d'écriture. Par conséquent, il n'est pas évident que vous en ayez une ou deux instances. En réalité, vous n'avez pas besoin d'une instance du tout.

6
JacquesB

même nom que la classe

Vrai, en Java

abréviation CTOR

Vrai

surcharge

Vrai

pas de type de retour

Eh bien ... pas de retour explicite. Un CTOR a toujours un type de retour implicite. La classe est le type. Un CTOR, lorsqu'il est utilisé avec le nouveau mot-clé, renvoie l'objet qu'il crée et que le type d'objet est la classe. Heureusement, lorsque vous définissez un CTOR, vous n'avez pas encore à dire le nom de la classe.

créer un objet d'une classe

C'est ce que ça fait.

chaque classe a un constructeur par défaut

Et bien non. Comme Wikipedia le dit:

Dans les deux Java et C #, un "constructeur par défaut" fait référence à un constructeur nullaire généré automatiquement par le compilateur si aucun constructeur n'a été défini pour la classe. Le constructeur par défaut appelle implicitement le nullaire de la superclasse constructeur, puis exécute un corps vide.

Wikipedia: constructeur par défaut

Donc non, chaque classe n'a pas de constructeur par défaut. Chaque classe aura du constructeur. Il n'a que le constructeur par défaut si vous ne le définissez pas explicitement.

BTW, "Nullary Constructor" est une façon fantaisie de dire un constructeur sans argument.

Lorsque, par exemple, une chaîne doit être renvoyée d'une classe à laquelle doit être appelée, une méthode pourrait être créée, c'est-à-dire un constructeur ne suffira pas car cela ne retournera rien.

Ugg. Regardez, il y a constructeurs qui "renvoient" juste bien. Ils vivent tous dans la catégorie classe de cordes .

Afin d'expliquer ce que je veux dire, j'ai créé une classe avec deux constructeurs et deux méthodes qui renvoient une chaîne.

Non vous ne l'avez pas fait. La sortie ne renvoie pas. Vos constructeurs ne retournent pas de chaînes. Ils "renvoient" des objets du type HelloWorldConstructor.

C'est pourquoi cela compile:

HelloWorldConstructor hwc = new HelloWorldConstructor();

Option 1: Il est possible de renvoyer une chaîne en appelant la méthode qui réside dans la classe.

Ce serait si vos méthodes ont renvoyé des chaînes. Ils retournent nul. Encore une fois, la sortie n'est pas de retour.

Option 2: Il est également possible de renvoyer une chaîne en appelant directement le constructeur.

Vous voulez dire sortie une chaîne. Oui, vous pouvez faire un constructeur faire d'autres choses en plus de construire simplement l'objet, comme l'avait l'intention de Dieu. ça ne veut pas dire que c'est une bonne idée .

Lorsque l'option 2 est choisie, deux objets doivent être créés au lieu d'une comme illustré par l'option 1, mais quand choisir l'option 2 et lorsque l'option 1? Dans ce cas, je pense qu'il est préférable de choisir l'option 1 comme un objet sera créé, mais l'option 2 pourrait être adaptée lorsque d'autres circonstances sont applicables.

La construction d'objets et d'utilisation d'objets devrait se produire dans des endroits séparés. Le brassant ensemble comme ça fait juste un gâchis.

Un constructeur doit être appelé directement quand ...

Lorsque vous construisez l'objet. Mettez-le dans une variable pratique et transmettez-la à quelque chose qui l'utiliserait.

La surcharge du constructeur sera effectuée quand ...

... Vous ne pouvez pas vous décider quel est votre objet dépendre de votre objet. Si vous pouvez penser à de nombreuses façons de construire le même objet, vous écrivez de nombreux constructeurs qui le construisent ces nombreuses manières.

Les méthodes seront appelées directement en appelant le constructeur par défaut lorsque ...

Désolé cela n'a aucun sens. Vous appelez des méthodes sur des objets quand il est temps de les utiliser. Vous appelez des constructeurs (par défaut ou non) quand il est temps de les construire.

Encore une fois, vous n'avez pas à construire et à utiliser en même temps. En fait, c'est généralement meilleur si vous ne le faites pas. Le polymorphisme ne fonctionne que lorsque vous ne savez pas exactement ce que vous parlez.

Quand appeler le constructeur et quand appeler la méthode en Java?

Meilleure réponse que j'ai pour cela vient de Injection de dépendance qui dit de faire votre construction comme haut la pile d'appels que vous le pouvez. Ce qui signifie à peu près faire la construction en principal. Personnellement, cela ne me dérange pas si vous utilisez certains modèles de création qui vous emmènent à la main pour un peu, mais gardez le code de comportement loin de là.

4
candied_orange

Notre travail de programmeurs est d'offrir une automatisation à divers domaines du monde réel - cela nécessite souvent que nous représentons divers concepts de domaine, leurs relations et leurs comportements ou leurs capacités.

Lors de la programmation, nous représentons divers concepts, relations et comportements utilisant les capacités de la langue de programmation pour définir des abstractions. Les abstractions, car d'une part, elles modélisent des concepts de domaine, des relations et des comportements, mais d'autre part, ils ont des détails de mise en œuvre internes (par exemple, des états et des algorithmes) que nous préférons boucler du programmateur client consommant (souvent nous-mêmes) réduire la complexité et faciliter les charges de programmeur.

La classe est un mécanisme de création d'abstraction. Il permet de grouper des méthodes et de l'état dans une seule entité pouvant être manipulée par un programmeur client consommant.

Fait important, la construction de classe permet des instances personnalisables. La personnalisation d'instance est généralement effectuée via des paramètres transmis aux constructeurs. Les constructeurs offrent les capacités pour lier une instance à certaines valeurs ou à certains autres objets.

Une fois construite, une instance peut désormais être utilisée pour accéder aux comportements et aux relations du concept, en utilisant ses méthodes.

Typique d'utiliser des abstractions, nous distinguons des préoccupations et créons des objets dans un endroit et utilisez-les dans un autre endroit et utilisez-les dans d'autres: la création d'objets représente une étape importante de certaines sortes, et une fois créée, une instance peut être transmise à être utilisée par un autre programmeur client consommant, Capable de travailler avec différentes instances d'objet du même type (classe ou interface), quelle que soit leur façon de créer.

Votre classe HelloWorldConstructor, est évidemment un échantillon arbitraire à des fins de votre question - nous ne nommerions généralement pas de classe après la construction, mais après l'abstraction que ses instances représentent.

Cette classe est également trop simpliste en ce qu'elle n'a pas d'état. (Bien qu'il soit parfois raisonnable d'avoir une instance sans état, des scénarios utiles impliquent généralement plusieurs classes différentes qui partagent une certaine interface (ou classe de base).) Sans état, le constructeur n'est rien contraignant - pour le mettre d'autre manière, Le constructeur ne participe pas à la création d'une instance personnalisée.

Néanmoins, tout ce qui étant dit, votre option 1 est davantage dans le style de la programmation orientée objet que l'autre car elle crée une instance et l'utilise ultérieurement - même si elle le fait dans des lignes de code immédiatement adjacentes.

Votre option 2 est effectivement une forme procédurale de programmation (c'est-à-dire pas OOP) puisque vous faites tout le travail dans le constructeur, puis je jette l'instance créée.

Un scénario typique consiste à utiliser le constructeur pour personnaliser une instance, puis, une fois créé, remettre l'instance personnalisée sur un code plus générique pouvant fonctionner avec une instance de cette classe. Ce code plus générique effectue ensuite quelques comportements utiles avec l'instance personnalisée.

Par exemple, ajoutez un paramètre au constructeur pour prendre un nom en tant que chaîne. Maintenant, le travail de la contruceur est simplement de capturer ce nom.

public class SayHi {
    private String name;

    public SayHi(String toWhom) {
        name = toWhom;  // capture customization parameter
    }

    public void saySomething(String a) {
        System.out.println(name + ": " + a);
    }
}

Nous pouvons maintenant créer des instances sur mesure différemment new SayHi("Erik") ... new SayHi("030") et utiliser ces différentes instances avec le même code.

3
Erik Eidt