design - ориентированное - философия ооп




Как вы проектируете объектно-ориентированные проекты? (16)

  1. исследования и мастер-проекты.
  2. Затем узнайте о проекте, управляемом доменом
  3. После этого изучите сбор требований

Я взял курс OOD несколько семестров и многому научился у него; например, писать UML и переводить документы требований в объекты и классы. Мы также изучили диаграммы последовательности, но почему-то я пропустил лекцию или что-то еще, они на самом деле не придерживались меня.

  1. Вы знаете о шаге 3. Вам нужно овладеть им. Я имею в виду, много практики, чтобы сделать его вторым. Это потому, что метод, который вы узнаете, просто против того, как мы привыкли. Поэтому вам нужно действительно овладеть им. В противном случае вы всегда окажетесь на своем первоначальном пути. Это как-то вроде Test Driven Process, где многие разработчики java отказываются от него после нескольких попыток. Если они полностью не овладеют им, в противном случае это просто бремя для них

  2. Напишите варианты использования, особенно для альтернативного курса. Альтернативный курс занимает более 50% нашего времени разработки. Обычно, когда ваш PM назначает вам задачу, например, создает систему входа в систему, он будет думать, что это прямолинейно, вы можете взять 1 день, чтобы закончить его. Но он никогда не учитывает, что вам нужно учитывать, 1. что, если пользователь вводит неверный пароль, 2. что, если пользователь вводит неверный пароль 3 раза, 3. что, если пользователь не вводит имя пользователя и т. Д. Вы должны их перечислить и показать своему премьеру, попросить его перенести сроки.

Я работаю над большим проектом (для меня), который будет иметь много классов и должен быть расширяемым, но я не уверен, как планировать свою программу и как классы должны взаимодействовать.

Я взял курс OOD несколько семестров и многому научился у него; например, писать UML и переводить документы требований в объекты и классы. Мы также изучили диаграммы последовательности, но почему-то я пропустил лекцию или что-то еще, они на самом деле не придерживались меня.

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

У меня есть копия Кодекса Стива Макконнелла, который я постоянно слышу, это потрясающе, здесь и в другом месте. Я прочитал главу о дизайне и, похоже, не получил информацию, которую я ищу. Я знаю, что он говорит, что это не вырезанный и высушенный процесс, который в основном основан на эвристике, но я не могу, кажется, взять всю свою информацию и применить ее к моим проектам.

Итак, что вы делаете на этапе разработки на высоком уровне (прежде чем начинать программирование), чтобы определить, какие классы вам нужны (особенно те, которые не основаны на каких-либо объектах реального мира) и как они будут взаимодействовать друг с другом ?

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


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


Если у вас есть опыт работы с доменом в проекте, вы будете работать, как говорят банки. Легко структурировать ваши объекты, и вы знаете, как эти улучшения появляются через день.

Если у вас нет такой экспертной работы с кем-то, кто обладает этим опытом и превращает эти идеи в технические детали.

Если вы смущены тем, как структурировать проект. Слегка следуйте книге «прагматический программист». Раньше я был в такой же ситуации, попробуйте прочитать главу из этой книги. вы увидите разницу. Он изменит то, как вы считаете разработчиком программного обеспечения.



Один из полезных методов - связать свое уникальное описание проблемы с тем, что вы можете найти в реальном мире. Например, вы моделируете сложную систему здравоохранения, которая будет штурмовать мир. Есть ли примеры, которые вы можете легко сформулировать для этого?

В самом деле. Наблюдайте за тем, как будет работать побочная аптека, или в комнате врача.

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

Затем, как только «игроки» в домене станут очевидными, и вы начнете моделировать свой код, выберете подход моделирования «поставщик-потребитель», т.е. ваш код является «провайдером» модели, и вы являетесь «потребителем» ».

Отношения с доменом и понимание его на высоком уровне являются ключевой частью любого проекта.


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

http://behaviour-driven.org/


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

Сначала попробуйте подумать о более высоком уровне абстракции. Подумайте о основных компонентах и ​​их обязанностях (их интерфейсе с другими компонентами), посмотрите на некоторые архитектурные шаблоны для вдохновения (нет, а не шаблонов проектирования, это слишком низкий уровень! MVC и Multi-Tier являются примерами архитектуры). Для достаточно крупных проектов такое представление должно содержать около 3-5 компонентов.

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

На данный момент вам не нужно полностью проектировать каждый компонент, хотя, вероятно, разумно иметь кусок кода, который реализует интерфейс невыполненных компонентов и генерирует простые, но полезные ответы. Таким образом, вы можете начать разработку (и дизайн) одного компонента за раз и проверить его в разумной степени.

Конечно, когда новые компоненты завершены, вы должны проверить, как (и если) они интегрируются друг с другом, прежде чем двигаться дальше.

Вкратце: возьмите ОО и принцип скрытия информации и поднимите его на другой уровень!

PS: Делайте много эскизов при проектировании, это просто настоящая архитектура!

PPS: Попытайтесь подойти к делу с разных ракурсов, подумайте вне коробки (хотя ящик может быть способ пойти), обсуждение со сверстниками может быть очень полезно для этого ... и вам есть о чем поговорить за обед.


Просто цитируя http://www.fysh.org/~katie/computing/methodologies.txt

И в основе RUP - небольшая область, где вам нужно использовать таланты дизайнера OO ... Если у вас их нет, это похоже на методологию для запуска 100 м.

Шаг 1: напишите о беге очень быстро. Шаг 2: Идите и нарисуйте план беговой дорожки. Шаг 3: идите и покупайте действительно плотные шорты лайкры. Шаг 4: бегите действительно, действительно, очень быстро. "

Это тот шаг 4, который является жестким. Но если вы сделаете много акцентов на 1,2,3 и 5, то, возможно, никто не заметит, и тогда вы, вероятно, могли бы заработать много денег, продавая методологию, чтобы быть спортсменами, которые думают, что есть какая-то «тайна», чтобы быть 100-метровой бегун над


Техника, которую я использовал в реальных проектах с разумным успехом, - это проект Responsible Driven Design, вдохновленный книгой Wirfs-Brock.

Начните с рассказов пользователей верхнего уровня и с коллегами на доске зарисуйте взаимодействия на высоком уровне, которые они подразумевают. Это дает вам первое представление о том, что такое большие модули; и итерация или две CRC-карты высокого уровня, такие как игра, вы должны стабилизировать список основных компонентов, что они делают и как они взаимодействуют.

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

Знать, когда остановиться - это вопрос суждения (который приходит только с опытом).


У меня недостаточно репутации, чтобы делать комментарии (присоединились сегодня), или я просто прокомментирую ответ Скотта Дэвиса. Добавив к тому, что он должен был сказать:

  1. Убедитесь, что вы знаете, что представляет собой ваша программа, прежде чем начать. Какова ваша программа? Что это не сделает? Какую проблему он пытается решить?

  2. Ваш первый набор вариантов использования не должен быть списком стилей всего, что программа в конечном итоге сделает. Начните с самого маленького набора прецедентов, которые вы можете придумать, и по-прежнему отражает суть вашей программы. Например, для этого веб-сайта могут использоваться основные случаи использования, задать вопрос , ответить на вопрос и просмотреть вопросы и ответы . Ничего о репутации, голосовании или вики сообщества, просто сырая сущность того, за что вы стреляете.

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

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

  5. Теперь вернитесь и выберите больше вариантов использования, напишите, как они будут работать, измените модель вашего класса и напишите больше кода. Точно так же, как ваш первый разрез, возьмите на себя как можно меньше, пока вы можете добавить что-то значимое. Промыть и повторить.

Только мои два цента. Надеюсь, это полезно.


Шаги, которые я использую для первоначального проектирования (переход к диаграмме классов), следующие:

  1. Сбор требований. Поговорите с клиентом и укажите варианты использования, чтобы определить, какие функции должно иметь программное обеспечение.

  2. Составьте повествование об отдельных случаях использования.

  3. Пройдите рассказ и выделите существительные (человек, место, предмет), как классы-кандидаты и глаголы (действия), как методы / поведение.

  4. Отбросьте дублирующиеся существительные и разделите общую функциональность.

  5. Создайте диаграмму классов. Если вы являетесь разработчиком Java, NetBeans 6.7 от Sun имеет UML-модуль, который позволяет создавать диаграммы, а также осуществлять обратную связь и БЕСПЛАТНО. Eclipse (с открытым исходным кодом Java IDE) также имеет структуру моделирования, но у меня нет опыта с ней. Вы также можете попробовать ArgoUML, инструмент с открытым исходным кодом.

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


Это часто повторяется, но полностью верно - понимайте свои данные.

Для ООП ваши классы должны описывать важные фрагменты информации и то, как они взаимодействуют.

Если у вас есть ментальная модель, которая хорошо описывает поведение и продолжительность жизни данных, вы легко сможете проложить свои занятия.

Это просто расширение: знайте, что именно вы пытаетесь сделать.


Я бы рекомендовал вам использовать BlueJ а также ActiveWriter, чтобы узнать, а также разработать хорошее понимание объектов. Рекомендованная книга также является хорошим ресурсом.

Из Wikipedia :

BlueJ - это интегрированная среда разработки для языка программирования Java, разработанная в основном в образовательных целях, но также подходящая для разработки небольших программ.

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

alt text http://www.ryanknu.com/ryan/bluej.png

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

alt text http://altinoren.com/activewriter/Images/Introduction_1.png


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

Если у вас есть опыт работы на один или два года, вы должны перейти к тому, что есть: как вы дошли до того, что знаете свои данные и понимаете, что именно вы пытаетесь сделать?

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

Но вы не получаете опыта, читая только книги. Вы должны учиться, работая в хорошей группе под хорошим руководством.

Если это невозможно, вы должны просто сделать это самостоятельно. Начните повторять, кодируя, вероятно, очень неприятный фрагмент кода, изучая свои ошибки, все это сбрасывая, кодируя лучшую и т. Д.

Вы узнаете много о своей кодовой базе. Инструменты - это инструменты, они ничего не научат.


Шаблоны проектирования

Создание шаблонов проектирования

Singleton - Убедитесь, что создан только один экземпляр класса и укажите глобальную точку доступа к объекту.

Factory (упрощенная версия Factory Method) - создает объекты, не подвергая клиентскую логику создания экземпляра и ссылается на вновь созданный объект через общий интерфейс.

Factory Method - определяет интерфейс для создания объектов, но позволяет подклассам решать, какой класс следует создавать, и ссылается на вновь созданный объект через общий интерфейс.

Абстрактная фабрика - предлагает интерфейс для создания семейства связанных объектов, без явного указания их классов.

Builder - определяет экземпляр для создания объекта, но позволяет подклассам решать, какой класс следует создавать и разрешать более тонкий контроль над процессом построения.

Прототип. Укажите типы объектов для создания с использованием прототипического экземпляра и создайте новые объекты, скопировав этот прототип.

Поведенческие шаблоны проектирования

Chain of Responsibiliy - позволяет избежать прикрепления отправителя запроса к его получателю, так как другие объекты могут обрабатывать запрос. - Объекты становятся частями цепочки, и запрос отправляется с одного объекта на другой по всей цепочке, пока один из объектов не обработает его.

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

Интерпретатор - с учетом языка определите представление для своей грамматики вместе с интерпретатором, который использует представление для интерпретации предложений в языке / Карта домена для языка, языка грамматики и грамматики для иерархического объектно-ориентированного проектирования

Итератор. Обеспечьте способ доступа к элементам совокупного объекта последовательно, не подвергая его базовому представлению.

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

Наблюдатель. Определите зависимость «один ко многим» между объектами, чтобы при изменении состояния одного объекта все его иждивенцы были уведомлены и обновлены автоматически.

Стратегия. Определите семейство алгоритмов, инкапсулируйте каждый из них и сделайте их взаимозаменяемыми. Стратегия позволяет алгоритму независимо варьироваться от клиентов, которые его используют.

Метод шаблона. Определите скелет алгоритма в операции, отложив некоторые шаги к подклассам / Template Method, позволяет подклассам переопределять определенные этапы алгоритма, не позволяя им изменять структуру алгоритма.

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

Null Object - предоставить объект в качестве суррогата за отсутствие объекта данного типа. / The Null Object Pattern обеспечивает интеллектуальное поведение, которое не делает ничего, скрывая детали от своих соавторов.

Структурные шаблоны проектирования

Адаптер - конвертирует интерфейс класса в другой интерфейс. / Adapter позволяет работать вместе, что в противном случае не может быть связано с несовместимыми интерфейсами.

Мост. Составление объектов в древовидных структурах для представления иерархии целого целого. / Composite позволяет клиентам обрабатывать отдельные объекты и композиции объектов равномерно.

Composite - компоновать объекты в древовидные структуры для представления иерархии целого целого. / Composite позволяет клиентам обрабатывать отдельные объекты и композиции объектов равномерно.

Decorator - динамически добавлять дополнительные объекты к объекту.

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

Memento - захватить внутреннее состояние объекта без нарушения инкапсуляции и, таким образом, обеспечить среднее значение для восстановления объекта в исходное состояние, когда это необходимо.

Прокси - предоставить «Заполнитель» для объекта для управления ссылками на него.


Изучите шаблоны проектирования . Это была моя личная революция за последние два года в отношении ООП. Получите книгу. Я бы порекомендовал вам это:

Образцы первых образцов дизайна

Он находится на Java, но может быть доступен для любого языка.





class-design