Разница между сплоченностью и муфтой

https://stackoverflow.com/questions/3085285

oop
ooad

28-09-2019
|

Вопрос

В чем разница между сплоченностью и муфтой?

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

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

Решение

Сплоченность Относится к тому, что может сделать класс (или модуль). Низкая сплоченность означала бы, что класс делает большое разнообразие действий - это широкое, не сфокусировано на том, что он должен сделать. Высокая сплоченность означает, что класс сосредоточен на том, что он должен делать, то есть только методы, относящиеся к намерению класса.

Пример низкой сплоченности:

-------------------
| Staff           |
-------------------
| checkEmail()    |
| sendEmail()     |
| emailValidate() |
| PrintLetter()   |
-------------------

Пример высокой сплоченности:

----------------------------
| Staff                   |
----------------------------
| -salary                 |
| -emailAddr              |
----------------------------
| setSalary(newSalary)    |
| getSalary()             |
| setEmailAddr(newEmail)  |
| getEmailAddr()          |
----------------------------

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

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

Другие советы

Высокая сплоченность в пределах Модули и низкое соединение между Модули часто рассматриваются как связанные с высоким качеством в языках программирования OO.

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

Глава 3 Строительство объектно-ориентированного программного обеспечения Meyer (2-е издание) Это отличное описание этих вопросов.

Сплоченность является признаком отношений в пределах модуль.

Связь является признаком отношений между модули.

Сплоченность

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

Связь

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

Проверьте это связь

Сплоченность является признаком того, как связаны и ориентированы на обязанности программного элемента.

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

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

Низкая сплоченность Результаты в монолитных классах, которые трудно поддерживать, понимать и уменьшать повторную пользу. Сходным образом Высокая муфта Результаты в классах, которые плотно связаны, и изменения не являются несложельными, трудно изменить и уменьшать повторное использование.

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

Поддержка получения связи
Отпустите соединение
Получить статистику о подключении VS
Получить статистику о подключении В.С. Время
Храните извлечение соединения и отпустите информацию в базу данных для отчетности позже.

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

С высокая сплоченность Мы можем назначить эти ответственности через классы и сделать его более удобным и многоразовым.

Показывать Низкая муфта Мы продолжим с высокой сплоченностью ConnectionPool Диаграмма выше. Если мы посмотрим на вышеуказанную диаграмму, хотя он поддерживает высокую сплоченность, ConnectionPool плотно связан с ConnectionStatistics класс и PersistentStore Это взаимодействует с ними напрямую. Вместо этого уменьшить муфту, мы могли бы представить ConnectionListener Интерфейс и пусть эти два класса реализуют интерфейс и дайте им зарегистрироваться с ConnectionPool класс. И то ConnectionPool Буду пережить эти слушатели и уведомить их о подключении и выпускать события и допускают меньшее соединение.

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

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

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

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

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

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

Это основные функциональные объекты должны только «знать» друг друга через интерфейс (ы), которые они реализуют. Реализация интерфейса вводит сплоченность как естественное следствие.

В то время как не реалистично в некоторых Senarios, это должна быть дизайнерская цель для работы.

Пример (очень схематичный):

public interface IStackoverFlowQuestion
      void SetAnswered(IUserProfile user);
      void VoteUp(IUserProfile user);
      void VoteDown(IUserProfile user);
}

public class NormalQuestion implements IStackoverflowQuestion {
      protected Integer vote_ = new Integer(0);
      protected IUserProfile user_ = null;
      protected IUserProfile answered_ = null;

      public void VoteUp(IUserProfile user) {
           vote_++;
           // code to ... add to user profile
      }

      public void VoteDown(IUserProfile user) {
          decrement and update profile
      }

      public SetAnswered(IUserProfile answer) {
           answered_ = answer
           // update u
      }
}

public class CommunityWikiQuestion implements IStackoverflowQuestion {
     public void VoteUp(IUserProfile user) { // do not update profile }
     public void VoteDown(IUserProfile user) { // do not update profile }
     public void SetAnswered(IUserProfile user) { // do not update profile }
}

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

public class OtherModuleProcessor {
    public void Process(List<IStackoverflowQuestion> questions) {
       ... process each question.
    }
}

лучшее объяснение Сплоченность исходит от чистого кода дяди Боба:

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

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

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

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

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

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

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

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

Типы кода с перспективы сплоченности и муфты:

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

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

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

прочитайте больше здесь

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

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

Сплоченность (CO-HESION): Соревнование что значит вместе, находка что значит прилипать. Отказ Система прилипания частиц различных веществ.

Для реального примера:

IMG вежливость

Целое больше, чем сумма частей -АРестотеля.

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

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

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

В этом блоге пост Я пишу об этом более подробно.

Сплоченность является признаком относительной функциональной прочности модуля.

Сплоченный модуль выполняет одну задачу, требующую мало взаимодействия с другими компонентами в других частях программы. Сказал просто, связывающий модуль должен (в идеале) делать только одну вещь.
Convental Trial:

«единомышленничество» модуля
oo Вид:

AppaceSeion подразумевает, что компонент или класс инкапсулирует только атрибуты и операции, которые тесно связаны друг с другом, а также к самому классу или компоненту
levels из сплоченности

 функционал

layer.

communicational.

Равный

procedural

temporal



Связь является признаком относительной взаимозависимости между модулями.

Соединение зависит от сложности интерфейса между модулями, точка, при которой ввод или ссылка сделана в модуль, и какие данные проходят через интерфейс.
Обычный вид: степень, в которой компонент подключен к другим компонентам и внешнему миру
OO View: качественная мера степени, к которой классы связаны друг с другом
Уровень муфты

ontent.

common

control.

stamp

data.data.

routine Call.

Type Использование

Inclusion или импорт

External #

Связь = взаимодействие / отношения между двумя модулями ...Сплоченность = взаимодействие между двумя элементами в модуле.

Программное обеспечение состоит из многих модулей. Модуль состоит из элементов. Рассмотрим модуль - это программа. Функция внутри программы является элементом.

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

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

Пример:

Связь = Связь между 2 разными семьями ...Сплоченность = связь между отцом-матери-ребенком в семье.

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

Публичный интерфейс класса является сплоченным, если все функции класса связаны с концепцией того, что класс представляет. Например, вместо того, чтобы класс Cashregister имея Cashregister и Coin Conceence Cohtion делает его на 2 класса - Cashregister и Coin Class.

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

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

Как правило, высокая сплоченность и низкая связь считается высококачественным Оом.

Срок сплоченность

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

Возможно, мы можем думать об этом таким образом. Часть имеет наибольшую сплоченность, когда она является единственной частью (делает только одну вещь и не может быть разбита дальше). Это то, что желательно в разработке программного обеспечения. Сплоченность просто другое имя для «одной ответственности» или «разделение проблем».

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

Лицензировано под: CC-BY-SA с атрибуция

Не связан с StackOverflow