Один класс проще и лучше, чем 6? - PullRequest
3 голосов
/ 16 февраля 2012

У меня есть процесс, который я автоматизирую в виде пошагового мастера с графическим интерфейсом.В основных терминах это длинный набор вычислений, который в конце концов дает вам спецификации для дизайна.

Он разбит на 6 блоков, и каждый последующий блок зависит от результатов и входных данных предыдущего блока.Первоначально я думал о том, чтобы сделать 6 отдельных «вычисляющих» классов, пока не начал думать о том, чтобы передать значения «как бы по линии».

Я только что выполнил аналогичную задачу, когда я ударил GUI в уже реализованной, очень похожей программе, где предыдущий парень делал это с отдельными классами, и было довольно трудно отследить их всех и убедиться, чтоони были переданы в правильные классы.

Я думал объединить их всех в один большой класс.У него было бы 6 методов, в которых я мог бы собирать и давать входные данные из каждого раздела графического интерфейса, и он делал бы свои вычисления за кулисами, а затем, после того как все 6 были вызваны, я могу просто создать один метод вывода, который собирает все важныеоценивает и выплевывает их.

Я склоняюсь к одному классу, потому что он проще, более похож на «черный ящик», и мне не нужно иметь грязные конструкторы, в которые я передаю ранее сделанный объектдо такой степени, что последний класс получает все 5 предыдущих, переданных ему, чтобы он мог использовать значения.

Теперь, когда я думаю об этом, этот один класс может быть «моделью» дизайна MVC и быть хорошим отдельным классом, к которому Controller и View получают доступ только через 7 видимых, очень простых методов.

Я также думаю, что это уменьшило бы объем памяти, так как с 6 отдельными классами они должны были бы существовать в течение той же продолжительности, что и 1 большой класс, за исключением того, что все внутренние компоненты Object реплицировались 6 раз.

Я вполне уверен в использовании одного класса, но я хотел спросить, является ли это ужасной ошибкой, идет ли она вразрез со всеми вещами, ориентированными на объекты и если я упускаю какое-то очевидное, гораздо лучшее решение.

Ответы [ 6 ]

3 голосов
/ 16 февраля 2012

Некоторые вещи, которые следует учитывать, помещая все шаги в один класс с сохранением состояния:

1) Будет ли на самом деле проще, если вы добавите код, который всегда будет в согласованном состоянии?Убедитесь, что методы вызываются в правильном порядке?

2) Могут ли пользователи вернуться назад?Вы абсолютно уверены, что никогда не будет требованием быть в состоянии вернуться назад?Означает ли это, что вам нужно еще 6 методов для «реверсирования» шагов и проверки состояния объекта?(Якобы в другой системе вы могли бы просто «getPrevious», если все сделано правильно.)

3) Кто управляет жизненным циклом этого объекта?Кто знает, когда вы закончите с этим, где хранится ссылка на него?В другой системе кажется, что каждый экран знает о своем собственном входе и своем собственном выходе.С одним объектом каждый экран знает обо всем состоянии процесса.Кроме того, первый и последний шаги, вероятно, будут обладать «специальными знаниями» о процессе, поскольку они, вероятно, должны будут содержать код для запуска и завершения жизненного цикла.

1 голос
/ 16 февраля 2012

Я сомневаюсь, что есть один простой ответ на ваш вопрос. Разделение кода на 6 классов или объединение в 1 класс будет зависеть от нескольких критериев, в том числе от того, насколько различны (функционально) эти 6 вычислений, насколько связаны значения ввода-вывода и т. Д.

При условии, что эти 6 частей являются 6 отдельными шагами в вычислении одной общей цели - и они действительно имеют смысл только вместе (то есть один из них не может быть вызван откуда-либо с каким-то разумным смыслом) - я бы пошел на подход с одним классом. Особенно, если в 6 различных наборах расчетов используются похожие / связанные алгоритмы и промежуточные значения / функции / и т. Д. По сути, это модель в мире MVC.

0 голосов
/ 16 февраля 2012

Я склоняюсь к одному классу, потому что он проще, более похож на «черный ящик»

Я не согласен. Идея черного ящика заключается в том, что внешнему миру не нужно знать детали реализации - программирование становится намного проще, код более читабельным, а ошибки - более изолированными, когда компоненты определяется только их входами и выходами. Вот радость дизайна, управляемого интерфейсом.

Наличие «одного большого класса», какими бы четкими ни были входы и выходы, на самом деле противоположно для программирования «черного ящика» и самой Java. Вся модель должна быть микроуправляемой, когда логические подкомпоненты должны управлять собой. (См. Комментарий @csturtz о SRP!).

Я также думаю, что это уменьшит объем памяти, как с 6 отдельными классами

Серьезно? Не беспокойся об этом. Объем памяти шести классов моделей будет незначительным по сравнению с Swing или JVM. Если память на самом деле серьезная проблема, сделайте это программой командной строки. Не жертвуйте потенциальной чистотой OO ради фантомной производительности; Java была построена таким образом, чтобы вы могли писать выразительный ОО-код, и JRE могла бы эффективно его запускать .


Похоже, вы реализуете проект конвейера, в котором ввод обрабатывается пошагово. Каковы преимущества представления этапов с классами?

  • Извлекайте общие функциональные возможности и данные в абстрактный класс или интерфейс, и вы избежите повторения.
  • Шесть - произвольное число. Что делать, если дополнительные этапы добавлены или некоторые удалены? С классом у вас есть своего рода прототип: создавайте столько экземпляров, сколько вам нужно, и управляйте ими таким же образом.

Как насчет этапов в конвейере, которые вы могли бы извлечь в интерфейс или абстрактный класс?

  • Текст, описывающий, что делает этот этап
  • Получено
  • Процесс расчета выработки
  • Набор алгоритмов, используемых для расчета (см. шаблон стратегии )
  • Сигнализация о завершении расчета
  • Возможность отменить прогресс
  • Расчетная мощность
  • Возможность пересчета

Я вполне уверен в использовании одного класса, но я хотел спросить, является ли это ужасной ошибкой, противоречит ли она всем объектам, ориентированным на объект, и если я упускаю какое-то очевидное, гораздо лучшее решение

Надеюсь, мы все прояснили.

0 голосов
/ 16 февраля 2012

Я думаю, что разделять вещи на 6 отдельных файлов и классов не имеет смысла, я согласен.

Я предлагаю пойти на внутренние занятия. Насколько я знаю, это довольно распространенная практика в программировании на Swing. Плюсы:

  • можно объединить в один исходный файл
  • Они могут быть хорошо документированы
  • имеет доступ ко всем переменным-членам в окружающем классе

Не упустите преимущества ООП:

  • может расширять другие классы (например, Thread для длительных вычислений)
  • может реализовывать интерфейсы (например, может быть зарегистрирован как ActionListener (Swing) или SelectionListener (SWT).

Поскольку внутренние классы можно сделать закрытыми, модель черного ящика будет полностью выполнена.

0 голосов
/ 16 февраля 2012

Другая альтернатива - создать 6 классов, каждый из которых реализует общий интерфейс, и вызвать интерфейс StageStage были бы хорошие крючки для передачи с / на другие Stage s.Такой модульный подход может сделать код более читабельным и изменяемым для следующего парня.

0 голосов
/ 16 февраля 2012

Пока код разбит на разные методы, и вы можете уменьшить цикломатическую сложность, я не вижу никаких минусов, с большим потенциалом для взлетов, если использовать только один класс, особенно с точки зрения использования памяти.

Добро пожаловать на сайт PullRequest, где вы можете задавать вопросы и получать ответы от других членов сообщества.
...