j'ai une petite question technique mais pas spécifiquement lié à java.
Dans une classe, lorsque l'on accède à des propriétés privées vaut-il mieux
y accéder via les accesseurs ou directement ?
En dehors de toute considération d'optimisation mais plutôt dans l'idée de
respecter le modèle objet.
A priori, je dirai que je reserve les accesseurs pour les appels externes à
ma classe et que je travail en local directement avec les propriétés
privées. Mais j'aimerais bien un avis plus éclairé voir même argumenté !
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Isammoc
j'ai une petite question technique mais pas spécifiquement lié à java.
Donc, tout dépend du langage.
Dans une classe, lorsque l'on accède à des propriétés privées vaut-il mieux y accéder via les accesseurs ou directement ?
Par définition, les propriétés privées sont... privés. C'est à dire que l'on ne peut les changer depuis l'extérieur de la classe (tout du moins en java).
Donc c'ets un usage bien établi qu'il faut les changer par leurs accesseurs. Meme à l'intérieur de la classe car si des contraintes de ta classe changeait tu pourrais modifier les valeurs limites, les valeurs possibles uniquement dans les accesseurs, donc avoir un code véritablement objet!
A priori, je dirai que je reserve les accesseurs pour les appels externes à ma classe et que je travail en local directement avec les propriétés privées. Mais j'aimerais bien un avis plus éclairé voir même argumenté !
Erf, faudrait que j'apprenne à lire les messages en entier.
Donc, je reformule ma réponse: il vaut mieux passer par les accesseurs afin de pouvoir controler a chaque fois la validité des valeurs. A moins bien sur que ce soit des valeurs spéciales.
Bj
Isammoc
j'ai une petite question technique mais pas spécifiquement lié à java.
Donc, tout dépend du langage.
Dans une classe, lorsque l'on accède à des propriétés privées vaut-il
mieux y accéder via les accesseurs ou directement ?
Par définition, les propriétés privées sont... privés.
C'est à dire que l'on ne peut les changer depuis l'extérieur de la classe
(tout du moins en java).
Donc c'ets un usage bien établi qu'il faut les changer par leurs
accesseurs. Meme à l'intérieur de la classe car si des contraintes de ta
classe changeait tu pourrais modifier les valeurs limites, les valeurs
possibles uniquement dans les accesseurs, donc avoir un code véritablement
objet!
A priori, je dirai que je reserve les accesseurs pour les appels
externes à ma classe et que je travail en local directement avec les
propriétés privées. Mais j'aimerais bien un avis plus éclairé voir
même argumenté !
Erf, faudrait que j'apprenne à lire les messages en entier.
Donc, je reformule ma réponse:
il vaut mieux passer par les accesseurs afin de pouvoir controler a chaque
fois la validité des valeurs. A moins bien sur que ce soit des valeurs
spéciales.
j'ai une petite question technique mais pas spécifiquement lié à java.
Donc, tout dépend du langage.
Dans une classe, lorsque l'on accède à des propriétés privées vaut-il mieux y accéder via les accesseurs ou directement ?
Par définition, les propriétés privées sont... privés. C'est à dire que l'on ne peut les changer depuis l'extérieur de la classe (tout du moins en java).
Donc c'ets un usage bien établi qu'il faut les changer par leurs accesseurs. Meme à l'intérieur de la classe car si des contraintes de ta classe changeait tu pourrais modifier les valeurs limites, les valeurs possibles uniquement dans les accesseurs, donc avoir un code véritablement objet!
A priori, je dirai que je reserve les accesseurs pour les appels externes à ma classe et que je travail en local directement avec les propriétés privées. Mais j'aimerais bien un avis plus éclairé voir même argumenté !
Erf, faudrait que j'apprenne à lire les messages en entier.
Donc, je reformule ma réponse: il vaut mieux passer par les accesseurs afin de pouvoir controler a chaque fois la validité des valeurs. A moins bien sur que ce soit des valeurs spéciales.
Bj
Isammoc
Miguel Moquillon
Bonjour,
j'ai une petite question technique mais pas spécifiquement lié à java.
Dans une classe, lorsque l'on accède à des propriétés privées vaut-il mieux y accéder via les accesseurs ou directement ? En dehors de toute considération d'optimisation mais plutôt dans l'idée de respecter le modèle objet.
A priori, je dirai que je reserve les accesseurs pour les appels externes à ma classe et que je travail en local directement avec les propriétés privées. Mais j'aimerais bien un avis plus éclairé voir même argumenté !
Tu te poses mal la question.
Partons du début pour pouvoir y répondre. - D'abord définis les propriétés qui décrivent les objets de ta classe (son interface quoi). - Parmi ces propriétés, certains sont ce que l'on appelle des attributs. Ce sont eux qui vont qualifier tes objets. Identifies les. - Une règle en conception objet : l'écriture des propriétés des objets doivent être uniforme, que celles-ci soient des attributs, des comportements ou des services. Dans les langages objet dérivés du C, comme Java, l'écriture uniforme est sous forme de fonction. => tes attributs sont écrits sous forme de fonctions (que bcp appelle malheureusement d'accesseur; j'abhore ce terme) "getter" en Java. - Choisi l'implémentation de tes attributs : sous forme de champs de données (mémoire) ou sous forme de calcul. Dans le cas de champs de données, celles-ci doivent être private ou protected en Java. - A partir de ces considérations, si dans les autres propriétés tu accèdent à un attribut, tu utilisent alors l'écriture fonctionnelle ("getter" en Java): -> si jamais tu changent ton choix d'implémentation (de champs vers calcul), ceci reste transparent pour tout le monde => peu d'impact dans ta classe (et chez les autres) -> Au sein des propriétés des objets, définies par la classe, lorsque tu as besoins d'utiliser les attributs, tu utilises bien l'"attribut" et non son implémentation. D'où aussi un usage des "setters" (en Java) private ou protected pour mettre à jour ces attributs.
Ceci sans tenir compte d'impératif de perfs mais seulement pour une bonne conception.
Miguel
Bonjour,
j'ai une petite question technique mais pas spécifiquement lié à java.
Dans une classe, lorsque l'on accède à des propriétés privées vaut-il mieux
y accéder via les accesseurs ou directement ?
En dehors de toute considération d'optimisation mais plutôt dans l'idée de
respecter le modèle objet.
A priori, je dirai que je reserve les accesseurs pour les appels externes à
ma classe et que je travail en local directement avec les propriétés
privées. Mais j'aimerais bien un avis plus éclairé voir même argumenté !
Tu te poses mal la question.
Partons du début pour pouvoir y répondre.
- D'abord définis les propriétés qui décrivent les objets de ta classe
(son interface quoi).
- Parmi ces propriétés, certains sont ce que l'on appelle des attributs.
Ce sont eux qui vont qualifier tes objets. Identifies les.
- Une règle en conception objet : l'écriture des propriétés des objets
doivent être uniforme, que celles-ci soient des attributs, des
comportements ou des services. Dans les langages objet dérivés du C,
comme Java, l'écriture uniforme est sous forme de fonction.
=> tes attributs sont écrits sous forme de fonctions (que bcp appelle
malheureusement d'accesseur; j'abhore ce terme) "getter" en Java.
- Choisi l'implémentation de tes attributs : sous forme de champs de
données (mémoire) ou sous forme de calcul. Dans le cas de champs de
données, celles-ci doivent être private ou protected en Java.
- A partir de ces considérations, si dans les autres propriétés tu
accèdent à un attribut, tu utilisent alors l'écriture fonctionnelle
("getter" en Java):
-> si jamais tu changent ton choix d'implémentation (de champs vers
calcul), ceci reste transparent pour tout le monde => peu d'impact dans
ta classe (et chez les autres)
-> Au sein des propriétés des objets, définies par la classe, lorsque
tu as besoins d'utiliser les attributs, tu utilises bien l'"attribut" et
non son implémentation. D'où aussi un usage des "setters" (en Java)
private ou protected pour mettre à jour ces attributs.
Ceci sans tenir compte d'impératif de perfs mais seulement pour une
bonne conception.
j'ai une petite question technique mais pas spécifiquement lié à java.
Dans une classe, lorsque l'on accède à des propriétés privées vaut-il mieux y accéder via les accesseurs ou directement ? En dehors de toute considération d'optimisation mais plutôt dans l'idée de respecter le modèle objet.
A priori, je dirai que je reserve les accesseurs pour les appels externes à ma classe et que je travail en local directement avec les propriétés privées. Mais j'aimerais bien un avis plus éclairé voir même argumenté !
Tu te poses mal la question.
Partons du début pour pouvoir y répondre. - D'abord définis les propriétés qui décrivent les objets de ta classe (son interface quoi). - Parmi ces propriétés, certains sont ce que l'on appelle des attributs. Ce sont eux qui vont qualifier tes objets. Identifies les. - Une règle en conception objet : l'écriture des propriétés des objets doivent être uniforme, que celles-ci soient des attributs, des comportements ou des services. Dans les langages objet dérivés du C, comme Java, l'écriture uniforme est sous forme de fonction. => tes attributs sont écrits sous forme de fonctions (que bcp appelle malheureusement d'accesseur; j'abhore ce terme) "getter" en Java. - Choisi l'implémentation de tes attributs : sous forme de champs de données (mémoire) ou sous forme de calcul. Dans le cas de champs de données, celles-ci doivent être private ou protected en Java. - A partir de ces considérations, si dans les autres propriétés tu accèdent à un attribut, tu utilisent alors l'écriture fonctionnelle ("getter" en Java): -> si jamais tu changent ton choix d'implémentation (de champs vers calcul), ceci reste transparent pour tout le monde => peu d'impact dans ta classe (et chez les autres) -> Au sein des propriétés des objets, définies par la classe, lorsque tu as besoins d'utiliser les attributs, tu utilises bien l'"attribut" et non son implémentation. D'où aussi un usage des "setters" (en Java) private ou protected pour mettre à jour ces attributs.
Ceci sans tenir compte d'impératif de perfs mais seulement pour une bonne conception.
