Как делают Вас, объект проектирования ориентировал проекты? [закрытый]

Как указано в Каков рабочий процесс, которого вы придерживаетесь при разработке программного обеспечения, которое собираетесь написать?

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

http://behaviour-driven.org/

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

Из Википедии :

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

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

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

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

_{(источник: altinoren.com )}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Вы задали вопрос, который многие авторы используют при написании книги. Существует ряд методологий, и вы должны выбрать тот, который вам кажется «самым красивым».
Я могу порекомендовать книгу Эрика Эванса "Domain Driven Design" . Также посетите сайт dddcommunity.org .

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

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

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

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

Это мой общий подход к разработке программного обеспечения. Он похож на спиральный дизайн, с короткими трехмесячными итерациями и элементами гибкой разработки, что позволяет вам изучить проблемы и узнать свое программное обеспечение и его область применения. Конечно, дело в масштабируемости, поэтому, если приложение настолько велико, что в нем участвуют сотни разработчиков, все немного сложнее, но в конце концов, я думаю, идея всегда одна и та же, Divine et impera .

Итак, подводя итоги:

1. На первой итерации вы получаете ее вкус и узнаете
2. На второй итерации вы очищаете свой продукт и готовите его к будущему
3. На третьей итерации вы добавить новые функции и узнать больше
4. goto 2

Боюсь, что это не тот ответ, люди хотели бы слышать . В любом случае позвольте мне высказать свое мнение.

ООП следует рассматривать как одну из парадигм, а не как высшую парадигму. ООП подходит для решения определенных проблем, например, для разработки библиотеки графического интерфейса. Он также вписывается в стиль разработки программного обеспечения, которому обычно следуют крупные компании-разработчики программного обеспечения - элитная команда дизайнеров или архитекторов излагает дизайн программного обеспечения в диаграммах UML или другом подобном носителе и менее просвещенная команда разработчиков переводит этот проект в исходный код. ООП мало что дает, если вы работаете в одиночку или с небольшой командой талантливых программистов. Потом, Лучше использовать язык, поддерживающий несколько парадигм и помогающий быстро создать прототип. Python, Ruby, Lisp / Scheme и т. Д. - хороший выбор. Прототип - это ваш дизайн. Тогда вы улучшите это. Используйте ту парадигму, которая лучше всего подходит для решения данной проблемы. При необходимости оптимизируйте горячие точки с помощью расширений, написанных на C или другом системном языке. Используя один из этих языков, вы также получаете расширяемость бесплатно не только на уровне программиста, но и на уровне пользователя. Такие языки, как Lisp, могут динамически генерировать и выполнять код, что означает, что ваши пользователи могут расширять приложение, написав небольшие фрагменты кода на языке, на котором написано само программное обеспечение! Или, если вы решите написать программу на C или C ++, подумайте о встраивании интерпретатора для небольшого языка, такого как Lua. Раскройте функциональные возможности как плагины , написанные на этом языке.

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

Подводя итог, я предпочитаю писать программное обеспечение:

1. Используйте динамический язык.
2. Напишите дизайн (прототип) на самом языке.
3. При необходимости оптимизируйте определенные области с помощью C / C ++.
4. Обеспечение расширяемости посредством интерпретатора самого языка реализации.

Последняя функция позволяет программному обеспечению легко адаптироваться к требованиям конкретного пользователя (включая меня!).

Техника, которую я использовал в реальных проектах с умеренным успехом, - это дизайн, основанный на ответственности, вдохновленный книгой Вирфс-Брока.

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

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

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

Сначала попробуйте мыслить с более высокого уровня абстракции. Для достаточно больших проектов такое представление должно содержать около 3-5 компонентов.

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

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

Конечно, Возьмите объектно-ориентированный принцип и принцип сокрытия информации и поднимите его на новый уровень!

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Нулевой объект - предоставить объект в качестве суррогата за отсутствие объекта данного типа. / Шаблон пустого объекта обеспечивает интеллектуальное поведение «ничего не делать», скрывая детали от его сотрудников.

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

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

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

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

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

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

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

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

Декоратор - динамическое добавление дополнительных функций к объекту.

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

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

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

Декоратор - динамическое добавление дополнительных функций к объекту.

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

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

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

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

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

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

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

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

Он написан на Java, но может быть расширен на любой язык.

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

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

Если вы запутались о том, как структурировать дизайн вашего проекта. СЛЕЗНО следуйте книге "прагматичный программист". Я был в такой же ситуации раньше, попробуйте прочитать главу из этой книги. вы увидите разницу. Это изменит ваш образ мышления как разработчика программного обеспечения.

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

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

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

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

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

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

И последнее - попробуйте прочитать это: Алгоритм творческого мышления

Самый интересный источник, о котором я знаю по этому поводу, - это часть D Object Oriented Software Construction, 2nd Edition , автор Bertrand Meyer.

Часть D: объектно-ориентированная методология : хорошо применяет метод

19: По методологии, 20: Дизайн шаблон: многопанельный интерактивный системы, 21: Пример наследования: «отменить» в интерактивной системе, 22: Как найти классы , 23: Принципы построения классов, 24: Использование наследование хорошо, 25: полезно техники, 26: Чувство стиля, 27: Объектно-ориентированный анализ, 28: процесс построения программного обеспечения, 29: Обучение методу

Интересно, что глава 22. Информация о том, как найти классы , доступна в Интернете.

Добавление к тому, что сказал Скотт Дэвис:

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

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

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

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

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

Всего два цента. Надеюсь, это будет полезно.

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

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

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

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

Я использую Test-Driven Design (TDD). Написание теста в первую очередь помогает создать чистый и правильный дизайн. См. http://en.wikipedia.org/wiki/Test-driven_development .