Pourquoi est-il bon de scinder un programme en plusieurs classes? [fermé]

Je suis toujours élève au lycée (entrée en 10e année) et je n'ai pas encore suivi de cours d'informatique à l'école. Tout ce que j'ai fait jusqu'à présent passe par des livres. Ces livres m'ont enseigné des concepts tels que l'héritage, mais en quoi le fractionnement d'un programme en plusieurs classes peut-il aider? Les livres ne me l'ont jamais dit.

Je demande cela principalement à cause d'un projet récent. C'est un jeu vidéo d'arcade, un peu comme un jeu Flash, comme certains l'ont dit (bien que je ne sache pas ce qu'est un jeu Flash ). Le fait est que ce n'est qu'une classe. Cela fonctionne parfaitement bien (un peu de décalage occasionnel cependant) avec une seule classe. Donc, je demande simplement comment le fractionner en plusieurs classes aiderait.

Ce projet était en Java et je suis la seule personne à y travailler, pour mémoire.

La réponse la plus simple est que si vous mettez tout dans une classe, vous devez vous préoccuper de tout en même temps lorsque vous écrivez un nouveau code. Cela peut fonctionner pour de petits projets, mais pour des applications énormes (nous parlons de centaines de milliers de lignes), cela devient rapidement presque impossible.

Pour résoudre ce problème, vous divisez des fonctionnalités en leurs propres classes et encapsulez toute la logique. Ensuite, lorsque vous souhaitez travailler sur la classe, vous n'avez pas besoin de penser à ce qui se passe dans le code. Vous pouvez simplement vous concentrer sur ce petit morceau de code. Cela est précieux pour travailler efficacement, mais il est difficile à apprécier sans travailler sur des applications énormes.

Bien sûr, il existe d'innombrables autres avantages à décomposer votre code en éléments plus petits: le code est plus facile à gérer, plus testable, plus réutilisable, etc., mais pour moi, le plus grand avantage est qu'il permet de gérer des programmes énormes en réduisant la quantité de code que vous utilisez. besoin de penser à la fois.

Eh bien, la réponse la plus simple pourrait être "Cela aide à organiser les choses." Si rien d’autre, vous pouvez le comparer aux sections d’un cahier - c’est tout simplement plus simple si vous avez "tout ce qui concerne l’UI" et "tout ce qui concerne le gameplay".

La réponse la plus sophistiquée est que la division du travail n’est pas simplement pratique, mais qu’elle est très importante pour gérer la complexité (et que "gérer la complexité" est à peu près le nom du jeu en matière de programmation). Les classes ou d'autres types de modules vous permettent de "séparer les préoccupations". Non seulement vous savez où chercher «des éléments liés à l'interface utilisateur», mais vous pouvez être sûr que si vous souhaitez modifier l'interface utilisateur, vous pouvez le faire au même endroit et vous n'avez pas à le faire. inquiétez-vous "maintenant, est-ce le seul endroit où je mets ma police sur Comic Sans?". Et vous pouvez effectuer un changement en sachant que son effet n’est valable que sur toute portée (petite) appropriée. Si tout est dans une classe ou un module unique, tout est essentiellement global,

Dans le cas spécifique des classes en tant que type de module logiciel, il existe également de nombreux comportements associés à une classe, et la plupart des développeurs du paradigme orienté objet trouvent très utile d'associer des noms significatifs aux classes liées au groupe. fonctionne ensemble. Donc, vous n'auriez probablement pas réellement de UIcours, vous auriez probablement de Buttoncours. Il existe tout un ensemble de connaissances et de techniques associées à la conception de classe orientée objet, et il s’agit du moyen le plus courant d’organiser de grands systèmes dans la programmation traditionnelle.

C'est une bonne question! Simple et bien posé. Eh bien ... la réponse n’est pas aussi facile à comprendre pour un étudiant en informatique qui ne sait probablement pas très bien en OO et qui n’a probablement pas travaillé sur l’expérience.

Je peux donc répondre en décrivant un scénario et en vous faisant imaginer à quel point un logiciel multi-classes est meilleur qu'un logiciel monolithique (créé par une seule classe):

• Lisibilité : Il est beaucoup plus difficile de parcourir et d’écrire du code dans un fichier de 10000 lignes que plusieurs fichiers petits et organisés.
• Réutilisabilité : Si vous écrivez une seule classe, vous pouvez vous perdre dans la duplication de code . Cela signifie plus de lignes de code et probablement plus de bugs (!)
• Testabilité : Pourquoi ne pas tester une seule fonctionnalité? Si vous isolez une fonctionnalité logique dans une classe, votre vie sera plus facile.
• Maintenabilité du code : Vous pouvez corriger un bogue ou améliorer les fonctionnalités de plusieurs classes en un seul endroit: les petites classes sympas.
• Structure du projet : oooooh pouvez-vous imaginer à quel point un projet avec un seul fichier source apparaîtra?

Il y a beaucoup de bonnes réponses ici, et je suis tout à fait d'accord avec elles, mais j'estime qu'il y a quelque chose de plus qui mérite d'être mentionné.

Comme vous l'avez dit, vous travaillez actuellement en solo sur votre projet. Cependant, à l'avenir, vous aurez parfois besoin de travailler en équipe. Pendant ces périodes, vous diviserez le travail (le projet sera vraisemblablement assez volumineux). En conséquence, il existe plusieurs options différentes (je suppose vraiment deux principales ). Vous pouvez avoir plusieurs copies d’un fichier et travailler sur des "parties" distinctes du fichier, puis les "combiner" avec un copier / coller ultérieurement, puis les modifier de manière à ce que vos parties puissent fonctionner ensemble, ou vous pouvez les fractionner complètement. facilement dans différentes classes et discutez de la façon dont vous allez écrire ces classes, et utilisez ces connaissances pour commencer.

Il faudra encore du travail pour intégrer toutes les pièces séparées, mais ce sera beaucoup plus facile à maintenir. Parce que le fichier x contient le code y et qu’il s’agit du code que vous devez modifier. Cela entre dans l’objet organisationnel dont parlent la plupart des autres réponses.

Tenir un programme dans la tête. Lien de Giorgio

En réalité, vous avez réinventé la programmation procédurale. Remarquez qu'il est tout à fait possible d'écrire un logiciel de cette façon et que le compilateur ne s'en souciera probablement pas. Pendant de nombreuses années, c’est ainsi que les choses se passaient jusqu’à ce que les ordinateurs deviennent plus rapides et que les outils s’améliorent.

Cela dit, si vous divisez votre code en différentes unités logiques (classes, modules, etc.), vous pouvez avoir beaucoup de morceaux de code courts et faciles à comprendre. cela peut être maintenu plus tard. Beaucoup de mes modules ont moins de 20 lignes de code. Je sais que tout le code sur un sujet donné est dans un endroit spécifique. Cela signifie également que si quelqu'un d'autre rejoint le projet, il aura beaucoup plus de facilité à trouver des choses.

Comme Gerald Sussman l'a dit, nos programmes devraient être écrits en premier pour que les gens puissent les lire et en second lieu pour que l'ordinateur puisse les exécuter. (Et si vous n'avez pas encore lu "Structure et interprétation des programmes informatiques, vous devriez le faire)"

L'une utilise plusieurs classes, car lorsque vous abordez des problèmes plus importants, vous constaterez qu'il est tout simplement impossible de garder une trace de tout quand il s'agit d'une grosse pile de code.

Vous devez simplement diviser et conquérir pour le gérer.

La programmation orientée objet est la meilleure idée que j'ai jamais vue en programmation. Mais ce n’est pas la meilleure chose dans tous les cas, vous avez besoin d’un peu d’expérience en programmation pour comprendre l’essentiel, et beaucoup de personnes prétendent pratiquer la programmation orientée objet alors qu’elles ne le sont pas.

Si vous pouvez rechercher une "programmation structurée", vous trouverez probablement quelque chose de plus utile immédiatement. (Assurez-vous de lire à propos de l' ancienne programmation structurée. Les anciens termes ont souvent une signification nouvelle et plus élaborée, et vous n'avez pas encore besoin de quelque chose d'extraordinaire.) Il s'agit d'un concept assez simple pour décomposer votre programme en sous-programmes, ce qui est beaucoup plus facile que le décomposer en objets. L'idée est que votre programme principal est une routine courte qui appelle des sous-routines ("méthodes" en Java) pour effectuer le travail. Chaque sous-programme ne sait que ce qu’il dit par ses paramètres. (L'un de ces paramètres peut être un nom de fichier, vous pouvez donc tricher un peu.) Donc, regarder l'en-tête d'un sous-programme / d'une méthode vous donne une idée rapide de ce qu'il fait, fait presque en un coup d'oeil.

Ensuite, tous les sous-programmes sont décomposés de manière similaire jusqu'à ce que quelques lignes de code sans aucun appel de méthode fassent le travail. Un programme principal qui appelle quelques méthodes, chacune appelant quelques méthodes, chacune d'entre elles .... Bases sur de petites méthodes simples qui font le travail. De cette façon, vous pouvez regarder n’importe quelle partie d’un très grand programme (ou petit programme) et comprendre rapidement ce qu’il fait.

Java est spécialement conçu pour les personnes qui écrivent du code orienté objet. Mais même le programme OO le plus intense utilise une programmation structurée, et vous pouvez toujours subvertir n’importe quel langage. (J'ai fait OO en clair C.) Vous pouvez donc faire du SP ou autre chose en Java. Oubliez les cours et concentrez-vous sur de grandes méthodes qui peuvent être décomposées en petites méthodes gérables. Je devrais ajouter que SP aide beaucoup à vous permettre de réutiliser votre code, ainsi qu’au principe DRY (google, cela signifie "ne vous répétez pas").

J'espère avoir expliqué pourquoi et comment scinder votre code en plusieurs parties sans faire appel à des "classes". Ils sont une excellente idée et sont juste pour les jeux et Java est un excellent langage pour la programmation orientée objet. Mais il vaut mieux savoir pourquoi vous faites ce que vous faites. Laissez OOP seul jusqu'à ce que cela commence à avoir un sens pour vous.

L'un des avantages est la possibilité de réutilisation. Un programme est essentiellement un groupe d’instructions regroupées. Vous constaterez que certaines de ces instructions conviennent également à d'autres programmes.

Disons que vous faites un jeu de saut. Plus tard, lorsque vous décidez de créer un jeu de canon, vous constaterez que le calcul physique que vous avez utilisé dans le jeu de saut est utile ici.

Ainsi, au lieu de le réécrire ou, pire encore, de le copier et de le coller dans le nouveau programme, vous en ferez une classe. Ainsi, la prochaine fois que vous créerez un autre jeu où la mécanique du jeu nécessite de la physique, vous pourrez simplement le réutiliser. Bien sûr, cela est simpliste mais j'espère que cela aura du sens.

Tout d’abord, notez que je suis un C ++ et Python, pas Java, donc certaines de ces choses peuvent ne pas s’appliquer aussi complètement. S'il vous plaît, corrigez-moi si je pose des hypothèses incorrectes sur le fonctionnement des classes en Java.

Les classes sont principalement utiles lorsqu'elles sont instanciées. Une classe dont aucune instance n'est créée n'est en réalité qu'un espace de nom glorifié. Si vous utilisez toutes vos classes de cette manière, les avantages de déplacer des éléments d'un espace de noms à un autre peuvent sembler insignifiants. Au mieux, vous gagnerez en disposant de données privées dans chacune d'elles et en encapsulant ainsi un peu les éléments.

Cependant, ce n'est pas là que les cours brillent. Considérez la Stringclasse: vous pourriez avoir toutes les mêmes fonctionnalités en utilisant des chartableaux et des fonctions statiques. À ce stade, les fonctions vous apportent un peu plus de sécurité et de sucre syntaxique. Vous pouvez écrire string.length()au lieu de length(char_array); ce n'est pas très grave, mais beaucoup de gens l'aiment encore. De plus, vous savez que si quelqu'un vous en a donné un String, il a été créé avec le Stringconstructeur et il doit fonctionner avec la lengthfonction - si la version du tableau ne peut pas gérer un caractère, il n'a aucun moyen de vous empêcher de le mettre ici. .

Ce n'est toujours pas ça, cependant. Le point clé est que les classes regroupent les données et les fonctions qui les exploitent et les abstinent. Quand vous avez une méthode, void f(Builder b)vous savez que vous allez en avoir une Builder, et vous pouvez vous attendre à ce qu'elle prenne en charge certains comportements. Cependant, vous ne savez rien des données ni des fonctions en cours d'exécution. En fait, les définitions des deux ne sont peut-être pas encore écrites au moment de l'écriture et de la compilation f.

Le premier point à comprendre est donc que les classes facilitent la transmission des données tout en veillant à ce qu'elles ne soient pas cassées. Le deuxième point est que la nature des données et la fonction (implémentations) d'un objet sont quelque chose à propos de l'objet, pas quelque chose que vous pouvez simplement dire à partir de son type.

L'idée est basée sur une règle générale appelée diviser pour régner .
Ce paradigme peut être utilisé presque partout. vous divisez un problème en problèmes plus petits, puis vous résolvez ces petits problèmes simples et bien connus.
La division de votre programme en classes est l’un des types de division qui a commencé à se généraliser au cours de la dernière décennie. Dans ce paradigme de programmation, nous modélisons notre problème à l'aide de certains objets et essayons de résoudre le problème en envoyant des messages entre ces objets.
Certaines personnes pourraient dire que cette approche est plus facile à comprendre, à développer et à déboguer.
Bien que certaines personnes ne soient pas d'accord :)

Il ne s’agit pas de scinder un programme en classes, mais de la façon dont vous modélisez votre application, c’est-à-dire dont vous visualisez des parties de votre application. La scission des choses est simplement un mécanisme que nous utilisons pour mieux comprendre les choses complexes. Ce n'est pas seulement avec la programmation. Imaginez un circuit imprimé avec de nombreux fils enchevêtrés les uns dans les autres, formant une structure complexe, chaque fil étant connecté quelque part (code spaghetti). Vous devrez suivre chaque fil jusqu'à son extrémité pour comprendre les connexions. Au contraire, imaginez des fils groupés et codés par couleur selon leur fonction. Il devient beaucoup plus facile de réparer les choses.

L'idée est que vous ne commencez pas par un programme long, puis que vous le divisez en classes. Mais vous modélisez d'abord votre application en termes d'objets / classes, puis vous les connectez pour créer des applications.