Comment trouver les classes dans un projet orienté objet?
Je suis un peu confus par certains concepts d'analyse et de conception orientés objet (OOA & D).
Dans OOA & D, quelles recommandations devraient être suivies afin de produire un modèle de domaine conceptuel viable?
Comment identifier les classes dans ce processus? J'ai lu un certain nombre de processus d'analyse et d'affinage en anglais qui indiquent les noms dans les cas d'utilisation comme classes candidates et les verbes comme opérations/responsabilités. Apparemment, il existe différentes manières d'appliquer ce raffinement afin de comprendre les classes.
À partir de là, il est possible, par exemple, d'utiliser des cartes CRC pour connaître les responsabilités et les collaborations, ainsi que d'autres candidats de classe. Mais je soupçonne que les cartes CRC ne sont pas très populaires, donc j'aimerais entendre parler d'autres méthodes (mais n'hésitez pas à approuver les cartes CRC si vous le souhaitez).
Et en ce qui concerne les détails de mise en œuvre (les classes les plus concrètes et techniques, pas celles conceptuelles), y a-t-il un processus en OOA & D pour les déterminer? Comment est-ce accompli?
N'hésitez pas à traiter OOA et OOD séparément et à clarifier les étapes qui y sont impliquées tout en répondant. Je crois que cela m'aidera à clarifier les choses sur la façon dont ces classes sont trouvées.
Dans OOA & D, quelles recommandations devraient être suivies afin de produire un modèle de domaine conceptuel précis?
Je recommanderais de prendre une copie de Domain-Driven Design par Eric Evans, c'est un excellent livre qui décrit le processus de discussion avec des experts du domaine et de distillation des idées dans un modèle logiciel. L'une des idées centrales du livre est de développer un langage omniprésent pour votre système que les parties prenantes et les programmeurs peuvent comprendre: s'il y a une "chose" dont les gens parlent tout le temps, alors elle devrait être probablement une classe dans votre code.
Et en ce qui concerne les détails de mise en œuvre (les classes les plus concrètes et techniques, pas celles conceptuelles), y a-t-il un processus en OOA & D pour les déterminer?
De manière générale, si vous avez les bons concepts de domaine et les bonnes interfaces, les classes "techniques" se mettront en place assez facilement. Des détails tels que les bases de données, les services Web et les conteneurs IoC existent uniquement pour connecter votre modèle de domaine au monde extérieur, alors choisissez simplement la solution la plus simple qui fait fonctionner le reste de votre logiciel.
Réponse courte: Non. Il n'y a pas de processus mécanique unifié qui produit un bon modèle d'objet. La modélisation est un processus créatif et social, il implique généralement de parler à et de comprendre d'autres personnes, au cours desquelles vous trouvez différentes façons de décomposer un problème.
Juste pour être clair, ce n'est même pas proche. Même juger le résultat est complètement subjectif, ce qui est surprenant étant donné que la plupart des gens croient que l'ingénierie logicielle est, bien, une certaine forme d '"ingénierie".
Par exemple, j'essaie généralement de respecter les contraintes suivantes:
- Toutes les phrases valides dans mon modèle (c'est-à-dire tout code syntaxiquement valide utilisant mes objets) devraient également être sémantiquement valides . Donc, si le code compile, il doit avoir une signification "commerciale".
- Tous les identificateurs doivent provenir du domaine ou référencer quelque chose du domaine problématique. Pas de cours techniques.
- Aucun objet ne doit jamais publier son état interne.
Beaucoup de gens seraient en désaccord avec ce qui précède. La plupart des gens sont très bien avec les objets "anémiques", c'est-à-dire les enregistrements et les structures, ce qui n'est pas le cas ci-dessus.
Ce que j'essaie de dire, c'est nous n'étions même pas d'accord à quoi devrait ressembler l'orientation objet. Bien sûr, il y a beaucoup de livres et de règles et de meilleures pratiques, mais beaucoup d'entre eux sont contradictoires ou dépendent de votre interprétation personnelle. Vous devez faire votre propre chemin.
Fondamentalement, nous voulons concevoir des abstractions utiles à leurs consommateurs (souvent nous, nous-mêmes).
Je préconise généralement de réfléchir davantage à la façon dont ces abstractions vont être utilisées (plutôt que, par exemple, à leurs détails de mise en œuvre). Les bonnes abstractions sont faciles à utiliser.
Parlons également des nombreux types d'abstractions que nous pouvons créer dans la plupart des langues OO:
- les fonctions
- des classes
- interfaces + classes et/ou classes de base + sous-classes
- espaces de noms
Chacun de ces ensembles rassemble plus de choses. Une fonction regroupe une capacité avec des entrées et sorties. Une classe regroupe plusieurs capacités (méthodes aka) avec un état encapsulé. Une interface (ou classe de base) crée une capacité sur plusieurs implémentations variées. Et un espace de noms définit une forêt de classes qui interagissent entre elles ou sont autrement liées.
Les bonnes abstractions sont terminées. Si vous pouvez naviguer de l'un à l'autre, peut-être aussi vice versa. Le client consommateur ne devrait pas avoir à gérer deux ou plusieurs éléments lorsqu'une seule abstraction peut faire le travail (par exemple, x & y séparés vs vs regroupés en tant que coordonnées; une paire de codage et de décodage de fonctions distinctes vs groupés ensemble en tant que interface).
Au-delà de la pensée en termes de classes seules, nous devrions plus largement modéliser les abstractions nécessaires pour un domaine: identifier les concepts et leurs relations, soutenir la navigation (traversée/rechercher/interroger), soutenir les comportements pour effectuer des changements (commandes), tout à faire les choses faciles pour le programmeur client consommateur afin qu'ils puissent travailler autant que possible directement en termes de domaine modélisé.
Le logiciel est évolutif, nous n'avons donc pas besoin de le perfectionner dès le départ. Nous pouvons commencer par un design et voir à quel point il est utile de consommer des clients. Si, par exemple, le client doit gérer plusieurs objets en tant que paire ou ensemble, cela indique une abstraction manquante qui devrait peut-être être modélisée.
De mon POV, il y a deux approches que j'appellerais analytical et synthetical (venant de la philosophie du XVIIIe siècle) ou peut-être plus moderne: top-down et bottom up. Je trouve que les anciens termes décrivent davantage parce qu'ils indiquent ce que vous faites: analyser les choses plutôt que les assembler.
I) La voie analytique
Lorsque vous entrez dans votre domaine, vous comprenez ce qui se passe. Disons que vous faites du commerce électronique vous avez affaire à Customers, Orders, Products etc .
quelles recommandations faut-il suivre pour produire un modèle de domaine conceptuel précis?
En descendant dans cette voie, la réponse est
Connaître votre domaine d'activité
C'est ce qu'on appelle analytique pour cette seule raison d'analyser le premier et de coder le second.
II) La voie synthétique
Si vous avez la chance que j'ai et que vous utilisez un langage qui prend en charge plusieurs paradigmes (comme Python ) dans mon cas, vous pouvez en tirer parti afin d'éviter le question sur les objets (et modules etc.) au début. De cette façon, vous construisez de bas en haut petit à petit - ou comme on l'appelle, vous synthétisez (groupez les choses ensemble et groupez les groupes), etc.
D'une manière générale, OOP concerne les données et le comportement et regroupement des données et comportement correspondant (il y a les trois piliers qui, selon moi, viennent plus tard).
Mais lorsque vous démarrez le projet la plupart du temps, vous ne savez pas comment regrouper vos données. Bien sûr - comme mentionné ci-dessus - il y a les "parties faciles" d'avoir un order.
Des langages comme Python vous permettent de reporter la question de savoir quelles classes sont nécessaires et à quoi elles devraient ressembler à une date ultérieure Vous commencez avec les fonctions intégrées de base et écrivez quelques fonctions et les regroupez plus tard dans des modules qui peuvent éventuellement devenir des classes. Mais parfois, vous voyez seulement que vous avez besoin une fonction.
Plus vous travaillez sur le projet, vous réalisez quelles données "attirent" quel comportement pour ainsi dire. Si vous avez un tas de fonctions traitant chacune du même type de données: pensez à une classe et nettoyez votre code.
quelles recommandations faut-il suivre pour produire un modèle de domaine conceptuel précis?
La réponse ici est:
Commencez sans aucune notion de objects et recherchez "l'attraction" des données et du comportement pendant le projet.
Je préfère ce dernier. Cela me permet de commencer mon travail plus tôt.
Mais pour faire les deux façons d'une manière raisonnable , vous devez avoir une expérience (accumulée).
En outre: je remplacerais le terme accurate par viable. Vous devez modéliser quelque chose qui fonctionne . Cela peut être inexact mais assez précis pour le moment.