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

Интерфейс в данном контексте, вероятно, относится к протоколу (protocol) в Swift.

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

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

   // Определение протокола с требуемым методом
   protocol Drawable {
       func draw()
   }
   
   // Структура соответствует протоколу и реализует метод
   struct Circle: Drawable {
       func draw() {
           print("Drawing a circle")
       }
   }
   
   // Класс соответствует протоколу и реализует метод
   class Square: Drawable {
       func draw() {
           print("Drawing a square")
       }
   }
   
   // Использование объектов, соответствующих протоколу
   func render(item: Drawable) {
       item.draw() // Вызывается поведение, определенное протоколом
   }
   
   render(item: Circle()) // Output: Drawing a circle
   render(item: Square()) // Output: Drawing a square
   

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

   // Протокол с методом
   protocol Greetable {
       func greet() -> String
   }
   
   // Дефолтная реализация метода в расширении протокола
   extension Greetable {
       func greet() -> String {
           return "Hello!"
       }
   }
   
   // Структура соответствует протоколу (использует дефолтную реализацию)
   struct Person: Greetable {
       // не предоставляет свою реализацию greet()
   }
   
   // Класс соответствует протоколу (предоставляет свою реализацию)
   class Robot: Greetable {
       func greet() -> String {
           return "Greetings, organic life form!"
       }
   }
   
   let person = Person()
   print(person.greet()) // Output: Hello! (используется дефолтная реализация)
   
   let robot = Robot()
   print(robot.greet()) // Output: Greetings, organic life form! (используется собственная реализация)
   

3. Полиморфизм: Использование типа протокола позволяет работать с объектами разных конкретных типов единообразно, через общий интерфейс, тем самым получая абстрактное поведение, определенное этим протоколом.

   // Массив объектов, соответствующих протоколу
   let drawables: [Drawable] = [Circle(), Square()]
   
   // Итерация по массиву и вызов поведения через протокол
   for item in drawables {
       item.draw()
   }
   // Output:
   // Drawing a circle
   // Drawing a square
   

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