Bonjour,
Une question me trotte.
Dans plusieurs documentations sur java, il est conseillé
de déclarer les attributs d'une classe en private, et d'accéder
à ceux-ci en utilisant des méthodes get() et set().
Bonjour,
Une question me trotte.
Dans plusieurs documentations sur java, il est conseillé
de déclarer les attributs d'une classe en private, et d'accéder
à ceux-ci en utilisant des méthodes get() et set().
Bonjour,
Une question me trotte.
Dans plusieurs documentations sur java, il est conseillé
de déclarer les attributs d'une classe en private, et d'accéder
à ceux-ci en utilisant des méthodes get() et set().
Ce qui veut dire que pour 10 champs déclarés en private dans une classe
il faudra coder 20 méthodes d'accés get() et set() (soit à peu prés 40
lignes),
si on veut que ceux-ci soient modifiable et éditable par classe.
Si on considére d'aprés la méthode COCOMO (Constructive Cost Model),
que le coût d'un logiciel qui ce calcule en partie par rapport aux nombres
de lignes codées livrables, il semble que cette technique augmente les coûts
de production.
Ne vaut t'il pas mieux déclarer les attributs en public et de ce fait
diminuer les coût de production ?
Ce qui veut dire que pour 10 champs déclarés en private dans une classe
il faudra coder 20 méthodes d'accés get() et set() (soit à peu prés 40
lignes),
si on veut que ceux-ci soient modifiable et éditable par classe.
Si on considére d'aprés la méthode COCOMO (Constructive Cost Model),
que le coût d'un logiciel qui ce calcule en partie par rapport aux nombres
de lignes codées livrables, il semble que cette technique augmente les coûts
de production.
Ne vaut t'il pas mieux déclarer les attributs en public et de ce fait
diminuer les coût de production ?
Ce qui veut dire que pour 10 champs déclarés en private dans une classe
il faudra coder 20 méthodes d'accés get() et set() (soit à peu prés 40
lignes),
si on veut que ceux-ci soient modifiable et éditable par classe.
Si on considére d'aprés la méthode COCOMO (Constructive Cost Model),
que le coût d'un logiciel qui ce calcule en partie par rapport aux nombres
de lignes codées livrables, il semble que cette technique augmente les coûts
de production.
Ne vaut t'il pas mieux déclarer les attributs en public et de ce fait
diminuer les coût de production ?
Bonjour,
Une question me trotte.
Dans plusieurs documentations sur java, il est conseillé
de déclarer les attributs d'une classe en private, et d'accéder
à ceux-ci en utilisant des méthodes get() et set().
Ce qui veut dire que pour 10 champs déclarés en private dans une classe
il faudra coder 20 méthodes d'accés get() et set() (soit à peu prés 40
lignes),
si on veut que ceux-ci soient modifiable et éditable par classe.
Si on considére d'aprés la méthode COCOMO (Constructive Cost Model),
que le coût d'un logiciel qui ce calcule en partie par rapport aux nombres
de lignes codées livrables, il semble que cette technique augmente les
coûts
de production.
Ne vaut t'il pas mieux déclarer les attributs en public et de ce fait
diminuer les coût de production ?
@+
--
______________________
Visitez mon site
http://laurent.sturm.free.fr
______________________
Bonjour,
Une question me trotte.
Dans plusieurs documentations sur java, il est conseillé
de déclarer les attributs d'une classe en private, et d'accéder
à ceux-ci en utilisant des méthodes get() et set().
Ce qui veut dire que pour 10 champs déclarés en private dans une classe
il faudra coder 20 méthodes d'accés get() et set() (soit à peu prés 40
lignes),
si on veut que ceux-ci soient modifiable et éditable par classe.
Si on considére d'aprés la méthode COCOMO (Constructive Cost Model),
que le coût d'un logiciel qui ce calcule en partie par rapport aux nombres
de lignes codées livrables, il semble que cette technique augmente les
coûts
de production.
Ne vaut t'il pas mieux déclarer les attributs en public et de ce fait
diminuer les coût de production ?
@+
--
______________________
Visitez mon site
http://laurent.sturm.free.fr
______________________
Bonjour,
Une question me trotte.
Dans plusieurs documentations sur java, il est conseillé
de déclarer les attributs d'une classe en private, et d'accéder
à ceux-ci en utilisant des méthodes get() et set().
Ce qui veut dire que pour 10 champs déclarés en private dans une classe
il faudra coder 20 méthodes d'accés get() et set() (soit à peu prés 40
lignes),
si on veut que ceux-ci soient modifiable et éditable par classe.
Si on considére d'aprés la méthode COCOMO (Constructive Cost Model),
que le coût d'un logiciel qui ce calcule en partie par rapport aux nombres
de lignes codées livrables, il semble que cette technique augmente les
coûts
de production.
Ne vaut t'il pas mieux déclarer les attributs en public et de ce fait
diminuer les coût de production ?
@+
--
______________________
Visitez mon site
http://laurent.sturm.free.fr
______________________
une solution c'est que ta fonction get ou set a en paramètre le nom
d'attribut que tu tu désire modifier ou afficher
du coup t'auras qu'une seul fonction
par rapport a la solution de rendre les attribut publique
l'inconvénient c'est que si tu modifie tes variable dans la classe il faudra
que tu change dans toutes les lignes ou tu faits appel a tes fonction
mais si tu utilise la première solution tu modifiera que la méthode
mais en général utiliser des paramètre en publique ça peut arriver mais il
faut le justifier
avec la première solution que j'ai donner je suppose que t'as plus de
justification
Cordialement
"laurent sturm" a écrit dans le message de
news:4153e7aa$0$751$Bonjour,
Une question me trotte.
Dans plusieurs documentations sur java, il est conseillé
de déclarer les attributs d'une classe en private, et d'accéder
à ceux-ci en utilisant des méthodes get() et set().
Ce qui veut dire que pour 10 champs déclarés en private dans une classe
il faudra coder 20 méthodes d'accés get() et set() (soit à peu prés 40
lignes),
si on veut que ceux-ci soient modifiable et éditable par classe.
Si on considére d'aprés la méthode COCOMO (Constructive Cost Model),
que le coût d'un logiciel qui ce calcule en partie par rapport aux nombres
de lignes codées livrables, il semble que cette technique augmente les
coûtsde production.
Ne vaut t'il pas mieux déclarer les attributs en public et de ce fait
diminuer les coût de production ?
@+
--
______________________
Visitez mon site
http://laurent.sturm.free.fr
______________________
---
Outgoing mail is certified Virus Free.
Checked by AVG anti-virus system (http://www.grisoft.com).
Version: 6.0.772 / Virus Database: 519 - Release Date: 01/10/2004
une solution c'est que ta fonction get ou set a en paramètre le nom
d'attribut que tu tu désire modifier ou afficher
du coup t'auras qu'une seul fonction
par rapport a la solution de rendre les attribut publique
l'inconvénient c'est que si tu modifie tes variable dans la classe il faudra
que tu change dans toutes les lignes ou tu faits appel a tes fonction
mais si tu utilise la première solution tu modifiera que la méthode
mais en général utiliser des paramètre en publique ça peut arriver mais il
faut le justifier
avec la première solution que j'ai donner je suppose que t'as plus de
justification
Cordialement
"laurent sturm" <laurent.sturm@free.fr> a écrit dans le message de
news:4153e7aa$0$751$8fcfb975@news.wanadoo.fr...
Bonjour,
Une question me trotte.
Dans plusieurs documentations sur java, il est conseillé
de déclarer les attributs d'une classe en private, et d'accéder
à ceux-ci en utilisant des méthodes get() et set().
Ce qui veut dire que pour 10 champs déclarés en private dans une classe
il faudra coder 20 méthodes d'accés get() et set() (soit à peu prés 40
lignes),
si on veut que ceux-ci soient modifiable et éditable par classe.
Si on considére d'aprés la méthode COCOMO (Constructive Cost Model),
que le coût d'un logiciel qui ce calcule en partie par rapport aux nombres
de lignes codées livrables, il semble que cette technique augmente les
coûts
de production.
Ne vaut t'il pas mieux déclarer les attributs en public et de ce fait
diminuer les coût de production ?
@+
--
______________________
Visitez mon site
http://laurent.sturm.free.fr
______________________
---
Outgoing mail is certified Virus Free.
Checked by AVG anti-virus system (http://www.grisoft.com).
Version: 6.0.772 / Virus Database: 519 - Release Date: 01/10/2004
une solution c'est que ta fonction get ou set a en paramètre le nom
d'attribut que tu tu désire modifier ou afficher
du coup t'auras qu'une seul fonction
par rapport a la solution de rendre les attribut publique
l'inconvénient c'est que si tu modifie tes variable dans la classe il faudra
que tu change dans toutes les lignes ou tu faits appel a tes fonction
mais si tu utilise la première solution tu modifiera que la méthode
mais en général utiliser des paramètre en publique ça peut arriver mais il
faut le justifier
avec la première solution que j'ai donner je suppose que t'as plus de
justification
Cordialement
"laurent sturm" a écrit dans le message de
news:4153e7aa$0$751$Bonjour,
Une question me trotte.
Dans plusieurs documentations sur java, il est conseillé
de déclarer les attributs d'une classe en private, et d'accéder
à ceux-ci en utilisant des méthodes get() et set().
Ce qui veut dire que pour 10 champs déclarés en private dans une classe
il faudra coder 20 méthodes d'accés get() et set() (soit à peu prés 40
lignes),
si on veut que ceux-ci soient modifiable et éditable par classe.
Si on considére d'aprés la méthode COCOMO (Constructive Cost Model),
que le coût d'un logiciel qui ce calcule en partie par rapport aux nombres
de lignes codées livrables, il semble que cette technique augmente les
coûtsde production.
Ne vaut t'il pas mieux déclarer les attributs en public et de ce fait
diminuer les coût de production ?
@+
--
______________________
Visitez mon site
http://laurent.sturm.free.fr
______________________
---
Outgoing mail is certified Virus Free.
Checked by AVG anti-virus system (http://www.grisoft.com).
Version: 6.0.772 / Virus Database: 519 - Release Date: 01/10/2004
Dans plusieurs documentations sur java, il est conseillé
de déclarer les attributs d'une classe en private, et d'accéder
à ceux-ci en utilisant des méthodes get() et set().
Dans plusieurs documentations sur java, il est conseillé
de déclarer les attributs d'une classe en private, et d'accéder
à ceux-ci en utilisant des méthodes get() et set().
Dans plusieurs documentations sur java, il est conseillé
de déclarer les attributs d'une classe en private, et d'accéder
à ceux-ci en utilisant des méthodes get() et set().
Bonjour,
Une question me trotte.
Dans plusieurs documentations sur java, il est conseillé
de déclarer les attributs d'une classe en private, et d'accéder
à ceux-ci en utilisant des méthodes get() et set().
Ce qui veut dire que pour 10 champs déclarés en private dans une classe
il faudra coder 20 méthodes d'accés get() et set() (soit à peu prés 40
lignes),
si on veut que ceux-ci soient modifiable et éditable par classe.
Si on considére d'aprés la méthode COCOMO (Constructive Cost Model),
que le coût d'un logiciel qui ce calcule en partie par rapport aux nombres
de lignes codées livrables, il semble que cette technique augmente les
coûts
de production.
Ne vaut t'il pas mieux déclarer les attributs en public et de ce fait
diminuer les coût de production ?
@+
--
______________________
Visitez mon site
http://laurent.sturm.free.fr
______________________
Bonjour,
Une question me trotte.
Dans plusieurs documentations sur java, il est conseillé
de déclarer les attributs d'une classe en private, et d'accéder
à ceux-ci en utilisant des méthodes get() et set().
Ce qui veut dire que pour 10 champs déclarés en private dans une classe
il faudra coder 20 méthodes d'accés get() et set() (soit à peu prés 40
lignes),
si on veut que ceux-ci soient modifiable et éditable par classe.
Si on considére d'aprés la méthode COCOMO (Constructive Cost Model),
que le coût d'un logiciel qui ce calcule en partie par rapport aux nombres
de lignes codées livrables, il semble que cette technique augmente les
coûts
de production.
Ne vaut t'il pas mieux déclarer les attributs en public et de ce fait
diminuer les coût de production ?
@+
--
______________________
Visitez mon site
http://laurent.sturm.free.fr
______________________
Bonjour,
Une question me trotte.
Dans plusieurs documentations sur java, il est conseillé
de déclarer les attributs d'une classe en private, et d'accéder
à ceux-ci en utilisant des méthodes get() et set().
Ce qui veut dire que pour 10 champs déclarés en private dans une classe
il faudra coder 20 méthodes d'accés get() et set() (soit à peu prés 40
lignes),
si on veut que ceux-ci soient modifiable et éditable par classe.
Si on considére d'aprés la méthode COCOMO (Constructive Cost Model),
que le coût d'un logiciel qui ce calcule en partie par rapport aux nombres
de lignes codées livrables, il semble que cette technique augmente les
coûts
de production.
Ne vaut t'il pas mieux déclarer les attributs en public et de ce fait
diminuer les coût de production ?
@+
--
______________________
Visitez mon site
http://laurent.sturm.free.fr
______________________
Si on considére d'aprés la méthode COCOMO (Constructive Cost Model),
que le coût d'un logiciel qui ce calcule en partie par rapport aux nombres
de lignes codées livrables, il semble que cette technique augmente les coûts
de production.
Si on considére d'aprés la méthode COCOMO (Constructive Cost Model),
que le coût d'un logiciel qui ce calcule en partie par rapport aux nombres
de lignes codées livrables, il semble que cette technique augmente les coûts
de production.
Si on considére d'aprés la méthode COCOMO (Constructive Cost Model),
que le coût d'un logiciel qui ce calcule en partie par rapport aux nombres
de lignes codées livrables, il semble que cette technique augmente les coûts
de production.
Bonjour,
Une question me trotte.
Dans plusieurs documentations sur java, il est conseillé
de déclarer les attributs d'une classe en private, et d'accéder
à ceux-ci en utilisant des méthodes get() et set().
Ce qui veut dire que pour 10 champs déclarés en private dans une classe
il faudra coder 20 méthodes d'accés get() et set() (soit à peu prés 40
lignes),
si on veut que ceux-ci soient modifiable et éditable par classe.
Si on considére d'aprés la méthode COCOMO (Constructive Cost Model),
que le coût d'un logiciel qui ce calcule en partie par rapport aux nombres
de lignes codées livrables, il semble que cette technique augmente les coûts
de production.
Ne vaut t'il pas mieux déclarer les attributs en public et de ce fait
diminuer les coût de production ?
Bonjour,
Une question me trotte.
Dans plusieurs documentations sur java, il est conseillé
de déclarer les attributs d'une classe en private, et d'accéder
à ceux-ci en utilisant des méthodes get() et set().
Ce qui veut dire que pour 10 champs déclarés en private dans une classe
il faudra coder 20 méthodes d'accés get() et set() (soit à peu prés 40
lignes),
si on veut que ceux-ci soient modifiable et éditable par classe.
Si on considére d'aprés la méthode COCOMO (Constructive Cost Model),
que le coût d'un logiciel qui ce calcule en partie par rapport aux nombres
de lignes codées livrables, il semble que cette technique augmente les coûts
de production.
Ne vaut t'il pas mieux déclarer les attributs en public et de ce fait
diminuer les coût de production ?
Bonjour,
Une question me trotte.
Dans plusieurs documentations sur java, il est conseillé
de déclarer les attributs d'une classe en private, et d'accéder
à ceux-ci en utilisant des méthodes get() et set().
Ce qui veut dire que pour 10 champs déclarés en private dans une classe
il faudra coder 20 méthodes d'accés get() et set() (soit à peu prés 40
lignes),
si on veut que ceux-ci soient modifiable et éditable par classe.
Si on considére d'aprés la méthode COCOMO (Constructive Cost Model),
que le coût d'un logiciel qui ce calcule en partie par rapport aux nombres
de lignes codées livrables, il semble que cette technique augmente les coûts
de production.
Ne vaut t'il pas mieux déclarer les attributs en public et de ce fait
diminuer les coût de production ?
