объяснение понятия без кода

Резюме Пример:

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

плотное соединение (детальный пример)

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

• Ключевой Момент #1: иными словами, если вы хотите изменить кожа, вам также придется изменить дизайн вашего тела а также потому, что они соединены вместе - они тесно связаны.

Бог не был хорошим объектно-ориентированным программистом.

Свободная муфта (подробный пример)

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

• это ключевой момент #2. если вы меняете рубашку, то вы не обязаны менять свое тело - когда вы можете сделать это, то у вас есть свободная связь. Когда вы не можете этого сделать, тогда у вас есть плотная связь.

вот основная концепция в двух словах.

почему все это важно?

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

например, практические примеры

• если кто-то хочет, чтобы их вывод в CSV-файл, а не JSON и т. д., или если вы хотите переключиться с MySQL на PostGreSQL, вы должны быть в состоянии сделать эти изменения очень легко в своем коде, без необходимости переписывать весь класс и тратить 10 часов отладки. Другими словами, вы не хотите тесно связывать свое приложение с конкретной реализацией базы данных (например, Mysql) или с конкретным выводом (например, CSV-файлы). Потому что, как это неизбежно в программном обеспечении, изменения придут. Когда они приходят, это намного проще, если ваши части кода слабо связаны.
• если кто-то хочет свой автомобиль на черный, вы не должны были перепроектировать весь автомобиль для того, чтобы сделать это. Автомобиль и его запасные части были бы прекрасным примером слабо связанной архитектуры (согласно комментариям @mnmopazem). Если вы хотите заменить свой двигатель на лучший, вы должны быть в состоянии просто удалить свой двигатель без особых усилий и поменять его на лучший. Если ваш автомобиль работает только с двигателями Rolls Royce ABC1234 и без других двигателей-тогда ваш автомобиль будет плотно связан с этим двигателем (Rolls Royce ABC1234). (Кстати, если это ваш пароль, тогда позор вам). Было бы лучше, если бы вы изменили дизайн вашего автомобиля так, что он будет работать с любой двигатель, так что он немного более свободно связан с его компонентами. Еще лучше было бы, если бы ваш автомобиль мог работать без двигателя вообще! Некоторое количество сцепления произойдет, но вы должны работать, чтобы свести его к минимуму, насколько это возможно. Зачем? Потому что когда требования изменяются мы все еще должны быть в состоянии поставить программное обеспечение хорошего качества, очень быстро и мы помогают в этой цели свободным соединением.

резюме

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

Картинка Атрибуции.

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

вы можете найти эта статья Мартина Фаулера (PDF) полезный.

программная разница между плотной муфтой и свободной муфтой ?

Плотная Связь Между Объектами Java

class Traveler
{
    Car c=new Car();
    void startJourney()
    {
       c.move();
    }
}

class Car
{
  void move()
  {
     // logic...
  }
}

Свободная Связь Между Объектами Java

class Traveler
{
    Vehicle v;
    public void setV(Vehicle v)
    {
      this.v = v;
    }      

    void startJourney()
    {
       v.move();
    }
}

//=========================устройство для сопряжения====================================

 Interface Vehicle
    {
       void move();
    }

//====================множественный интерфейс корабля инструмента класса. Первый класс====

class Car implements Vehicle
{
    public void move()
    {
         // logic
    }
}

//===================второй класс================

class Bike implements Vehicle
{
    public void move()
    {
         // logic
    }
}

вообще плотное соединение плохо внутри но большую часть времени, потому что оно уменьшает гибкость и re-usability кода, оно делает изменения очень более трудным, оно затрудняет testability etc.

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

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

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

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

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

Observer design pattern является хорошим примером для создания классов слабо связанных, вы можете посмотреть на него в Википедия.

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

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

отрывок из моего блоге на муфта:

что это Жесткая Связь: -

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

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

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

namespace DNSLooseCoupling
{
    public class ShoppingCart
    {
        public float Price;
        public int Quantity;

        public float GetRowItemTotal()
        {
            return Price * Quantity;
        }
    }

    public class ShoppingCartContents
    {
        public ShoppingCart[] items;

        public float GetCartItemsTotal()
        {
            float cartTotal = 0;
            foreach (ShoppingCart item in items)
            {
                cartTotal += item.GetRowItemTotal();
            }
            return cartTotal;
        }
    }

    public class Order
    {
        private ShoppingCartContents cart;
        private float salesTax;

        public Order(ShoppingCartContents cart, float salesTax)
        {
            this.cart = cart;
            this.salesTax = salesTax;
        }

        public float OrderTotal()
        {
            return cart.GetCartItemsTotal() * (2.0f + salesTax);
        }
    }
}

проблемы с приведенным выше примером

плотное соединение создает некоторые трудности.

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

есть определенные инструменты, которые обеспечивают инъекцию зависимостей через свою библиотеку, например, в .net у нас есть библиотека ninject .

Если вы собираетесь дальше в java, то весна предоставляет этой возможности.

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

скажите в своем коде, что вы пишете

Myclass m = new Myclass();

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

свободная связь это означает, что степень зависимости между двумя компонентами очень низкая Бывший.GSM SIM Плотная связь это означает, что степень зависимости между двумя компонентами очень высока. бывший. CDMA Mobile

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

Свободная Связь = МОК Смотрите этой для более легкого объяснения.

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

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

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

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

например, у нас есть система, которая может отправлять выходные данные в двух или более способов как В JSON-вывод, КШМ-вывода и т. д.

Плотно Соединенную

public interface OutputGenerator {
    public void generateOutput();
}

public class CSVOutputGenerator implements OutputGenerator {
    public void generateOutput() {
        System.out.println("CSV Output Generator");
    }
}

public class JSONOutputGenerator implements OutputGenerator {
    public void generateOutput() {
        System.out.println("JSON Output Generator");
    }
}

// In Other Code, we write Output Generator like...
public class Class1 {
    public void generateOutput() {
        // Here Output will be in CSV-Format, because of hard-coded code.
        // This method tightly coupled with CSVOutputGenerator class, if we want another Output, we must change this method.
        // Any method, that calls Class1's generateOutput will return CSVOutput, because Class1 is tight couple with CSVOutputGenerator.
        OutputGenerator outputGenerator = new CSVOutputGenerator();
        output.generateOutput();
    }
}

в приведенном выше примере, если мы хотим изменить вывод в JSON, то нам нужно найти и изменить весь код, потому что Class1 тесно связан с классом CSVOutputGenerator.

Свободный Сочетании

public interface OutputGenerator {
    public void generateOutput();
}

public class CSVOutputGenerator implements OutputGenerator {
    public void generateOutput() {
        System.out.println("CSV Output Generator");
    }
}

public class JSONOutputGenerator implements OutputGenerator {
    public void generateOutput() {
        System.out.println("JSON Output Generator");
    }
}

// In Other Code, we write Output Generator like...
public class Class1 {
    public void generateOutput(OutputGenerator outputGenerator) {
        // if you want to write JSON, pass object of JSONOutputGenerator (Dependency will be passed externally to this method)
        // if you want to write CSV, pass object of CSVOutputGenerator (Dependency will be passed externally to this method)

        // Due to loose couple with class, we don't need to change code of Class1, because Class1 is loose coupled with CSVOutputGenerator or JSONOutputGenerator class
        // Any method, that calls Class1's generateOutput will desired output, because Class1 does not tight couple with CSVOutputGenerator or JSONOutputGenerator class
        OutputGenerator outputGenerator = outputGenerator;
        output.generateOutput();
    }
}

если создание/существование объекта зависит от другого объекта, который не может быть адаптирован, его плотная связь. И, если зависимость может быть адаптирована, ее свободная связь. Рассмотрим пример в Java:

class Car {

    private Engine engine = new Engine( "X_COMPANY" ); // this car is being created with "X_COMPANY" engine
    // Other parts

    public Car() { 
        // implemenation 
    }

}

клиент Car класс может создать один только с движком" X_COMPANY".

рассмотрите возможность разрыва этой связи с возможностью изменить это:

class Car {

    private Engine engine;
    // Other members

    public Car( Engine engine ) { // this car can be created with any Engine type
        this.engine = engine;
    }

}

теперь, a Car не зависит от движка "X_COMPANY", как это может быть создано с помощью типов.

специфическое Примечание Java: С помощью Java интерфейсы только для соединения саке-это не правильный подход, дизайн. В Java интерфейс имеет цель-действовать как контракт, который интриз обеспечивает поведение/преимущество де-сцепления.

комментарий Билла Росмуса в принятом ответе имеет хорошее объяснение.