Pourquoi utiliser des getters et setters/accesseurs?

Il y a en fait de nombreuses bonnes raisons envisager d'utiliser des accesseurs plutôt que d'exposer directement les champs d'une classe - au-delà de l'argument de l'encapsulation et de faire les futurs changements plus facile.

Ici sont quelques-unes des raisons pour lesquelles je suis conscient de:

• Encapsulation de comportement associé à l'obtention ou à la définition de la propriété - ce qui permet à des fonctionnalités supplémentaires (comme la validation) à ajouter plus facilement plus tard.
• Cacher la représentation interne de la propriété, tout en exposant une propriété à l'aide d'une variante de la représentation.
• L'isolation de votre interface publique de changement - en permettant à l'interface publique à rester constante, tandis que la mise en œuvre des modifications sans affecter les consommateurs existants.
• Le contrôle de la durée de vie et la gestion de la mémoire (élimination) de la sémantique de la propriété - particulièrement important dans la non-mémoire gérée environnements (comme C++ ou Objective-C).
• Fournir un débogage interception point lors de la modification d'une propriété à l'exécution de débogage quand et où un bien changé pour une valeur particulière peut être assez difficile sans cela, dans certaines langues.
• D'améliorer l'interopérabilité avec les bibliothèques qui sont conçus pour fonctionner à l'encontre de la propriété de lecture/définition - Moqueur, la Sérialisation, et WPF viennent à l'esprit.
• Permettant aux héritiers de changer la sémantique de la façon dont la propriété se comporte et est exposée en substituant les getter/setter.
• Permettant le getter/setter pour être passée autour d'expressions lambda plutôt que de valeurs.
• Getters et setters peut permettre différents niveaux d'accès - par exemple l'obtenir peut être public, mais l'ensemble pourrait être protégé.

Un champ public n'est pas pire qu'un getter/setter paire qui ne fait que retourner le terrain et en lui attribuant. Tout d'abord, il est clair que (dans la plupart des langues) il n'y a pas de différence fonctionnelle. Toute différence doit être dans d'autres facteurs, comme la maintenabilité ou la lisibilité.

Souvent mentionné avantage de getter/setter paires, n'est-ce pas. Il y a cette demande, vous pouvez changer la mise en œuvre et vos clients n'ont pas à être recompilé. Soi-disant, les poseurs vous permettent d'ajouter des fonctionnalités comme la validation plus tard et vos clients n'ont même pas besoin de le savoir. Cependant, l'ajout d'une validation à un setter est un changement de ses conditions préalables, une violation du contrat précédent, qui a été, tout simplement, "vous pouvez mettre n'importe quoi ici, et vous pouvez obtenir la même chose plus tard à partir de la lecture".

Donc, maintenant que vous avez cassé le contrat, la modification de chaque fichier dans la base de code est quelque chose que vous devriez vous voulez à faire, ne pas éviter. Si vous éviter cela, vous êtes en faisant l'hypothèse que tout le code suppose que le contrat de ces méthodes est différent.

Si cela ne devrait pas avoir été le contrat, l'interface a été permettant aux clients de mettre l'objet dans des états non valides. C'est l'exact opposé de l'encapsulation Si ce champ n'a pas vraiment pu être réglé à n'importe quoi depuis le début, pourquoi n'était-ce pas la validation depuis le début?

Ce même argument s'applique à d'autres avantages supposés de ces pass-through getter/setter paires: si plus tard vous décidez de changer la valeur en cours de jeu, vous êtes de rompre le contrat. Si vous remplacez la valeur par défaut de la fonctionnalité dans une classe dérivée, de façon au-delà de quelques modifications inoffensifs (comme l'exploitation forestière ou à d'autres comportements observables), vous êtes de rompre le contrat de la classe de base. C'est une violation de la Liskov Substituabilité Principe, qui est considéré comme l'un des principes de OO.

Si une classe a muettes getters et setters pour chaque champ, il est une classe qui n'a pas d'invariants que ce soit, pas de contrat. Est-ce vraiment une conception orientée objet? Si l'ensemble de la classe a, c'est ceux des getters et setters, c'est juste un idiot de données de titulaire, et de la muette que les détenteurs de données devrait ressembler muette que les détenteurs de données:

class Foo {
public:
    int DaysLeft;
    int ContestantNumber;
};

L'ajout de passage-à travers les getter/setter paires à une telle classe n'ajoute pas de valeur. D'autres classes devraient fournir des activités, et pas seulement les opérations que les champs fournissent déjà. C'est la façon dont vous pouvez définir et maintenir utile invariants.

Client: "Que puis-je faire avec un objet de cette classe?".

Designer: "Vous pouvez lire et écrire plusieurs variables."

Client: "Oh... cool, je suppose?"

Il y a des raisons d'utiliser les accesseurs et mutateurs, mais si ces raisons n'existent pas, faire des getter/setter paires dans le nom de faux encapsulation des dieux n'est pas une bonne chose. Des raisons valables de le faire getters ou setters comprennent les choses est souvent mentionné comme le potentiel de changements que vous pouvez faire plus tard, comme la validation ou différentes représentations internes. Ou peut-être la valeur doit être lisible par les clients, mais pas en écriture (par exemple, la lecture de la taille d'un dictionnaire), de sorte qu'un simple getter est un bon choix. Mais ces raisons devraient être là quand vous faites le choix, et pas seulement comme un potentiel de chose que vous souhaitez peut-être plus tard. C'est une instance de YAGNI (Vous Ain't Gonna Besoin).

Il existe de nombreuses raisons. Mon préféré, c'est quand vous avez besoin de changer le comportement de réguler ou ce que vous pouvez définir sur une variable. Par exemple, disons que vous avez eu une setSpeed(int vitesse) de la méthode. Mais vous voulez que vous ne pouvez définir une vitesse maximale de 100. Vous feriez quelque chose comme:

public void setSpeed(int speed) {
  if ( speed > 100 ) {
    this.speed = 100;
  } else {
    this.speed = speed;
  }
}

Maintenant, si PARTOUT dans votre code vous avez été en utilisant le champ public et puis vous avez réalisé vous avez besoin de la condition ci-dessus? Ont plaisir de la chasse à chaque utilisation du domaine public au lieu de simplement modifier votre setter.

Mes 2 cents 🙂

Un avantage de accesseurs et des mutateurs, c'est que vous pouvez effectuer la validation.

Par exemple, si foo était public, je pourrais facilement le régler à null et puis quelqu'un d'autre pourrait essayer d'appeler une méthode sur l'objet. Mais il n'est plus là! Avec un setFoo méthode, je pourrais assurer que foo n'a jamais été mis à null.

Des accesseurs et des mutateurs également permettre l'encapsulation - si vous n'êtes pas censé voir la valeur une fois son ensemble (peut-être qu'il est défini dans le constructeur et ensuite utilisé par des méthodes, mais jamais censé être changé), il n'aura jamais été vu par n'importe qui. Mais si vous pouvez permettre à d'autres classes pour les voir ou de les modifier, vous pouvez fournir le bon accesseur et/ou mutateur.

Eh bien, je veux juste ajouter que même si ils sont parfois nécessaires pour l'encapsulation et la sécurité de vos variables/objets, si nous voulons le code d'un Objet réel Programme Orienté, alors nous avons besoin de ARRÊTER LE GASPILLAGE DE L'ACCESSEURS, provoquer parfois nous comptons beaucoup sur eux quand ils ne sont pas vraiment nécessaires et qui fait presque la même chose que si l'on met les variables publiques.

Je sais c'est un peu tard, mais je pense qu'il y a certaines personnes qui sont intéressés à la performance.

J'ai fait un petit test de performance. J'ai écrit une classe "NumberHolder" qui, ainsi, est titulaire d'un Entier. Vous pouvez lire cet Entier à l'aide de la méthode de lecture
anInstance.getNumber() ou en accédant directement le numéro à l'aide anInstance.number. Mon programme lit le nombre 1 000 000 000 d'fois, par deux moyens. Ce processus est répété cinq fois, et le temps est imprimé. J'ai obtenu le résultat suivant:

Time 1: 953ms, Time 2: 741ms
Time 1: 655ms, Time 2: 743ms
Time 1: 656ms, Time 2: 634ms
Time 1: 637ms, Time 2: 629ms
Time 1: 633ms, Time 2: 625ms

(Temps 1 est la voie la plus directe, de Temps 2 est le getter)

Vous le voyez, le getter est (presque) toujours un peu plus vite. Ensuite, j'ai essayé avec différents nombres de cycles. Au lieu de 1 million de dollars, j'ai utilisé 10 millions d'euros et 0,1 million de dollars.
Les résultats:

De 10 millions de cycles:

Time 1: 6382ms, Time 2: 6351ms
Time 1: 6363ms, Time 2: 6351ms
Time 1: 6350ms, Time 2: 6363ms
Time 1: 6353ms, Time 2: 6357ms
Time 1: 6348ms, Time 2: 6354ms

Avec 10 millions de cycles, les temps sont presque les mêmes.
Voici 100 mille dollars (0,1 million de cycles:

Time 1: 77ms, Time 2: 73ms
Time 1: 94ms, Time 2: 65ms
Time 1: 67ms, Time 2: 63ms
Time 1: 65ms, Time 2: 65ms
Time 1: 66ms, Time 2: 63ms

Également avec différentes quantités de cycles, de la lecture est un peu plus rapide que la façon habituelle. J'espère que cela vous a aidé.

J'ai passé un bon moment de penser ce fil pour le Java cas, et je crois que les vraies raisons sont:

1. Code de l'interface, pas de la mise en œuvre
2. Interfaces uniquement spécifier les méthodes, les champs

En d'autres termes, la seule façon vous pouvez spécifier un champ dans une interface est de fournir une méthode pour écrire une nouvelle valeur et une méthode pour la lecture de la valeur actuelle.

Ces méthodes sont l'infâme getter et setter....

Nous utilisons les getters et les setters:

• pour la réutilisabilité
• pour effectuer la validation dans les étapes ultérieures de la programmation

Getter et setter sont les interfaces publiques à accès privé aux membres de la classe.

Encapsulation mantra

L'encapsulation mantra est de rendre les champs privés et les méthodes publiques.

Des Méthodes de lecture: Nous pouvons accéder aux variables privées.

Setter: Nous pouvons modifier les champs privés.

Même si les getter et setter ne pas ajouter de nouvelles fonctionnalités, nous pouvons changer notre esprit de revenir plus tard pour faire de cette méthode

• mieux;
• plus sûr; et
• plus rapide.

N'importe où une valeur peut être utilisée, une méthode qui renvoie cette valeur peut être ajoutée. Au lieu de:

int x = 1000 - 500

utilisation

int x = 1000 - class_name.getValue();

En d'autres termes

Supposons que nous avons besoin de stocker les détails de cette Person. Cette Person a les champs name, age et sex. En faisant cela implique la création de méthodes pour name, age et sex. Maintenant, si nous avons besoin de créer une autre personne, il devient nécessaire de créer les méthodes pour name, age, sex une fois de plus.

Au lieu de cela, nous pouvons créer un bean class(Person) avec les méthodes getter et setter. Donc, demain, il nous suffit de créer des objets de ce Bean class(Person class) chaque fois que nous avons besoin d'ajouter une nouvelle personne (voir la figure). Ainsi, nous sommes en réutilisant les champs et méthodes de classe d'haricot, ce qui est beaucoup mieux.

Dans des langues qui ne supportent pas les "propriétés" (C++, Java) ou qui nécessitent une recompilation des clients lors de la modification de champs de propriétés (C#), à l'aide de méthodes get/set est plus facile à modifier. Par exemple, l'ajout d'une logique de validation à un setFoo méthode ne nécessite pas de modification de l'interface publique d'une classe.

Dans des langues qui soutien "réel" propriétés (Python, Ruby, peut-être Smalltalk?) il n'y a pas de point de méthodes get/set.

L'une des principales bases de conception OO: Encapsulation!

Il vous donne de nombreux avantages, dont vous pouvez changer la mise en œuvre du getter/setter derrière les coulisses, mais les consommateurs de cette valeur va continuer à travailler aussi longtemps que le type de données reste la même.

Vous devez utiliser les accesseurs et mutateurs lorsque:

• Vous avez affaire à quelque chose qui est conceptuellement un attribut, mais:
  • Votre langue ne possède pas de propriétés (ou de certains d'mécanisme similaire, comme Tcl de la variable de traces), ou
  • Votre langue de support de la propriété n'est pas suffisante pour ce cas d'utilisation, ou
  • De votre langue (ou parfois de votre cadre) idiomatiques conventions encourager les getters ou setters pour ce cas d'utilisation.

Donc, c'est très rarement un général OO question, c'est un langage spécifique à la question, avec des réponses différentes pour différentes langues (et les différents cas d'utilisation).

À partir d'un OO théorie de point de vue, les getters et les setters sont inutiles. L'interface de votre classe est ce qu'il fait, pas ce qu'elle est à l'état. (Si non, vous avez écrit à l'envers de la classe.) Dans des cas très simples, où la signification d'une classe n'est juste, par exemple, représentent un point en coordonnées rectangulaires,* les attributs font partie de l'interface; les getters et les setters juste nuage. Mais dans quoi que ce soit, mais des cas très simples, ni les attributs, ni les getters et les setters sont une partie de l'interface.

Mettre une autre façon: Si vous croyez que les consommateurs de votre classe ne doit même pas savoir que vous avez une spam attribut, encore moins être en mesure de le changer bon gré mal gré, en leur donnant un set_spam méthode est la dernière chose que vous voulez faire.

_{* Même pour cette classe simple, vous ne pouvez pas forcément envie de permettre la mise au x et y valeurs. Si c'est vraiment une classe, ne devrait-il pas des méthodes comme translate, rotate, etc.? Si c'est seulement une classe parce que votre langue n'ont pas de dossiers/struct/uplets nommé, alors ce n'est pas vraiment une question de OO...}

Mais personne n'en est jamais fait général OO design. Ils font la conception et la mise en œuvre, dans une langue spécifique. Et dans certaines langues, les getters et les setters sont loin d'être inutiles.

Si votre langue n'ont pas de propriétés, puis le seul moyen de représenter quelque chose qui est conceptuellement un attribut, mais est en fait calculé, ou validés, etc., est par des getters et les setters.

Même si votre langue n'ont des propriétés, il peut y avoir des cas où ils sont insuffisantes ou inappropriées. Par exemple, si vous souhaitez autoriser des sous-classes pour le contrôle de la sémantique d'un attribut, dans des langues sans accès dynamique, une sous-classe peut pas remplacer une propriété calculée pour un attribut.

Comme pour le "que faire si je veux changer de mise en œuvre plus tard?" question (qui est répété plusieurs fois dans différents formulation à la fois l'OP et l'on a accepté la réponse): Si c'est vraiment une pure mise en œuvre du changement, et que vous avez commencé avec un attribut, vous pouvez la changer en une propriété sans affecter l'interface. À moins, bien sûr, que votre langue ne supporte pas que. Donc c'est vraiment juste le même cas à nouveau.

Aussi, il est important de suivre les idiomes de la langue (ou le cadre) que vous utilisez. Si vous écrivez belle robe Rubis style de code en C#, tout expérimenté C# développeur d'autre que vous allez avoir des difficultés à le lire, et c'est mauvais. Certaines langues sont plus les cultures autour de leurs conventions que les autres.—et il ne peut pas être une coïncidence que Java et Python, qui sont sur les extrémités opposées du spectre de façon idiomatique getters sont, arrive d'avoir les deux plus forts cultures.

Au-delà de lecteurs humains, il y aura des bibliothèques et des outils qui attendent de vous que vous suivez les conventions, et faire de votre vie plus difficile si vous n'avez pas. L'accrochage de l'Interface du Générateur de widgets à rien mais ObjC propriétés, ou l'utilisation de certains Java se moquant de bibliothèques sans getters, est tout simplement faire de votre vie plus difficile. Si les outils sont importants pour vous, ne les combattez pas.

Code évolue. private est idéal pour quand vous avez besoin d'un membre de données de protection. Finalement, toutes les classes doivent être sorte de "miniprograms" qui ont une interface bien définie, que vous ne pouvez pas juste vis avec le fonctionnement interne de.

Cela dit, de développement de logiciels n'est pas à propos de la mise bas que la version finale de la classe, comme si vous étiez en appuyant sur la fonte de la statue sur le premier essai. Pendant que vous travaillez avec elle, le code est plus comme de l'argile. Il évolue comme vous le développer et d'en apprendre plus sur le domaine du problème à résoudre. Au cours du développement des classes peuvent interagir les uns avec les autres que ce qu'ils devraient (dépendance que vous prévoyez de facteur), fusionner ou séparer. Je pense donc que le débat se résume à des gens qui ne veulent pas religieusement écrire

int getVar() const { return var ; }

De façon à avoir:

doSomething( obj->getVar() ) ;

Au lieu de

doSomething( obj->var ) ;

N'est pas seulement getVar() visuellement bruyant, il donne cette illusion que gettingVar() est en quelque sorte un processus plus complexe qu'il ne l'est vraiment. Comment vous (comme la classe écrivain) concernant le caractère sacré de la var est particulièrement déroutant pour un utilisateur de votre classe, si il a un genre de setter -- puis on dirait que vous êtes de mettre en place ces portes afin de "protéger" quelque chose vous insistez est précieux, (le caractère sacré de la var), mais encore vous le concède varprotection ne vaut pas beaucoup par la possibilité pour quiconque de juste venir et set var à la valeur qu'il veut, sans même jeter un oeil à ce qu'ils font.

Donc je programme comme suit (en supposant un "agile approche de type" -- c'est à dire quand j'écris du code ne sachant pas exactement ce qu'il en sera de faire/ne pas avoir le temps ou l'expérience de plan d'élaborer une cascade de style de l'interface set):

1) Commencez avec tous les membres du public pour les objets de base de données avec des données et le comportement. C'est pourquoi, dans tout mon C++ "exemple de code", vous remarquerez que je l'utilise struct au lieu de class partout.

2) Lorsqu'un objet interne de comportement pour un membre de données devient assez complexe (par exemple, il aime garder un intérieur std::list dans un certain ordre), accesseur type de fonctions sont écrites. Parce que je suis de programmation par moi-même, je n'ai pas toujours définir le membre private tout de suite, mais quelque part en bas de l'évolution de la classe, le membre sera "promu" à une protected ou private.

3) les Classes qui sont bien définis et ont des règles strictes concernant leurs internes (c'est à dire ils savent exactement ce qu'ils font, et vous n'êtes pas à "baiser" (terme technique) avec ses internes) sont donnés à la class désignation, par défaut les membres privés, et seule une poignée de membres sont autorisés à être public.

Je trouve cette approche me permet d'éviter de rester assis là et religieusement écriture lecture/définition lorsqu'un grand nombre de données de membres qui ont migré hors, décalé, etc ... durant les premiers stades d'une classe de l'évolution.

Getters et setters sont utilisés pour mettre en œuvre deux des aspects fondamentaux de la Programmation Orientée Objet, qui sont:

1. Abstraction
2. Encapsulation

Supposons que nous ayons une classe d'Employés:

package com.highmark.productConfig.types;

public class Employee {

    private String firstName;
    private String middleName;
    private String lastName;

    public String getFirstName() {
      return firstName;
    }
    public void setFirstName(String firstName) {
       this.firstName = firstName;
    }
    public String getMiddleName() {
        return middleName;
    }
    public void setMiddleName(String middleName) {
         this.middleName = middleName;
    }
    public String getLastName() {
        return lastName;
    }
    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    public String getFullName(){
        return this.getFirstName() + this.getMiddleName() +  this.getLastName();
    }
 }

Ici les détails de mise en œuvre de Nom Complet est caché de l'utilisateur et n'est pas accessible directement à l'utilisateur, à la différence d'un attribut public.

Relativement moderne avantage de getters/setters est c'est fait, il est plus facile de parcourir le code dans étiqueté (indexée) des éditeurs de code. E. g. Si vous voulez voir qui définit un membre, vous pouvez ouvrir la hiérarchie d'appel de l'incubateur.

D'autre part, si le membre est public, les outils ne permettent pas possible de filtrer les accès en lecture/écriture pour le membre. Donc, vous avez à crapahuter si toutes les utilisations du membre.

En outre, c'est à "l'avenir" de votre classe. En particulier, la modification d'un champ à un bien immobilier est une ABI pause, donc si vous ne décidez plus tard que vous avez besoin de plus logique que de simplement "set/get le terrain", alors vous avez besoin pour briser ABI, qui, bien sûr, crée des problèmes pour quoi que ce soit d'autre est déjà compilé avec votre classe.

Je ne peux penser à une raison pourquoi vous ne voulez pas seulement tout public.

Par exemple, la variable que vous avez jamais eu l'intention de l'utiliser en dehors de la classe pourrait être accessible, même irdirectly par une chaîne variable d'accès (c'est à dire de l'objet.de l'élément.de l'origine.x ).

En ayant la plupart du temps tout privé, et seulement les choses que vous voulez étendre et, éventuellement, reportez-vous à la dans les sous-classes protégées, et n'ayant static final des objets en tant que public, alors vous pouvez contrôler ce que d'autres programmeurs et les programmes peuvent utiliser dans l'API et ce qu'il peut accéder et qu'il ne peut pas en utilisant les setters et getters pour accéder à la substance que vous voulez que le programme, ou peut-être d'autres programmeurs qui vient de se produire pour utiliser votre code, peut modifier dans votre programme.

Je voulais poster un exemple concret j'ai tout juste terminé:

fond - je hibernate des outils pour générer les mappages pour ma base de données, une base de données que je suis l'évolution que je développe. J'ai changer le schéma de base de données, pousser les modifications, puis exécutez hibernate des outils pour générer le code java. Tout est bien et bon jusqu'à ce que je veux ajouter des méthodes à correspond à des entités. Si je modifie les fichiers générés, ils seront écrasés à chaque fois que je fais une modification de la base de données. J'ai donc étendre les classes générées comme ceci:

package com.foo.entities.custom
class User extends com.foo.entities.User{
     public Integer getSomething(){
         return super.getSomething();             
     }
     public void setSomething(Integer something){
         something+=1;
         super.setSomething(something); 
     }
}

Ce que j'ai fait ci-dessus est de remplacer les méthodes existantes sur la super classe avec mes nouvelles fonctionnalités (quelque chose+1) sans jamais toucher la classe de base. Même scénario si vous avez écrit une classe il y a un an et que vous voulez aller à la version 2 sans modifier vos classes de base (test de cauchemar). espérons que cela aide.

Si vous voulez une variable en lecture seule, mais ne veulent pas le client d'avoir à changer la manière dont ils accèdent, essayez ce basé sur un modèle de classe:

template<typename MemberOfWhichClass, typename primative>                                       
class ReadOnly {
friend MemberOfWhichClass;
public:
template<typename number> inline bool   operator==(const number& y) const { return x == y; } 
template<typename number> inline number operator+ (const number& y) const { return x + y; } 
template<typename number> inline number operator- (const number& y) const { return x - y; } 
template<typename number> inline number operator* (const number& y) const { return x * y; }  
template<typename number> inline number operator/ (const number& y) const { return x / y; } 
template<typename number> inline number operator<<(const number& y) const { return x << y; }
template<typename number> inline number operator^(const number& y) const  { return x^y; }
template<typename number> inline number operator~() const                 { return ~x; }
template<typename number> inline operator number() const                  { return x; }
protected:
template<typename number> inline number operator= (const number& y) { return x = y; }       
template<typename number> inline number operator+=(const number& y) { return x += y; }      
template<typename number> inline number operator-=(const number& y) { return x -= y; }      
template<typename number> inline number operator*=(const number& y) { return x *= y; }      
template<typename number> inline number operator/=(const number& y) { return x /= y; }      
primative x;                                                                                
};      

Exemple D'Utilisation:

class Foo {
public:
ReadOnly<Foo, int> cantChangeMe;
};

Rappelez-vous, vous aurez besoin d'ajouter au niveau du bit et des opérateurs unaires ainsi! C'est juste pour vous obtenir a commencé

Bien que n'étant pas commun pour les getter et setter, l'utilisation de ces méthodes peuvent aussi être utilisées dans des AOP/modèle de proxy utilise.
par exemple pour la vérification de la variable, vous pouvez utiliser l'AOP à la vérification de mise à jour de la valeur.
Sans getter/setter il n'est pas possible, sauf changer le code partout.
Personnellement je n'ai jamais utilisé l'AOP pour cela, mais il montre un avantage de l'utilisation de getter/setter.