Преимущества свободной связи интерфейса Java в реальном мире?

Question

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

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

      Apple apple =new Apple();
//Apple is tightly coupled to Main class

apple.eat();

//If eat method signature is Changed to drink in the Apple class of course we need to change the method name here in Main class also right?.

Давайте посмотрим на слабую связь

      class interface Fruits{
    void drink();
}
    
Class Apple implements Fruits {
    @Override
    public void drink (){
        // Printing some message;
    }
}
    
class Main{
    public static void main(String [] args){
        Fruits apple = new Apple ();
        //is this loose coupled 
        apple.drink();
    }
}

Если я изменяю сигнатуру метода в слабой связи с drink на pour, мне нужно изменить код в трех разных местах.

1. сигнатура метода внутри интерфейса Fruits (выпей, чтобы налить)
2. класс Apple (переопределение метода с напитка на налив)
3. внутри основного класса (вызов метода из apple.drink в apple.pour)

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

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

Код жесткой связи

      class Main {
    //boiler plate code
    
    Apple apple = new Apple();
}

В будущем, если я создам класс Mango, мне нужно будет создать еще один объект в основном классе, например Mango mango = new Mango();

Код слабой связи

      class Main {
    //boiler plate code
    Fruits apple =new Apple():
    //In future if i Change Apple() to Mango() no error will occur here because of the interface reference type(Fruits). 
}

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

Пожалуйста, помогите мне понять аналогию с фруктами.

Answer 1

Прежде всего, вы должны проверить эти два принципа: принцип разделения интерфейса и принцип инверсии зависимостей. Это зависит от вашей проблемы.

Вернемся к вашему вопросу.

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

Предположим, у вас есть класс Fruit Press.

- Плотная связь.

      class FruitPress {
  private Apple apple;

  public FruitPress(Apple fruit){
    this.apple = fruit;
  }

  public press() {
    apple.press();
  }
}

Класс FruitPress зависит от класса Apple. Таким образом, FruitPress тесно связан с Apple.

-Свободная связь

      class FruitPress {
  private Fruit fruit;

  public FruitPress(Fruit fruit){
    this.fruit = fruit;
  }

  public press() {
    fruit.press();
  }
}

Ваш класс FruitPress теперь слабо связан.

А теперь создайте основной класс. Если вы не используете слабую связь, вы должны реализовать два класса прижима (ApplePresser, OrangePresser) для вашей проблемы. Но теперь у нас есть одна реализация.

      class Main {   
  public static void main(String [] args){ 
    FruitPress applePresser = new FruitPress(new Apple());
    FruitPress orangePresser = new FruitPress(new Orange());
  
    //doing something.
  }
}