🤔 Что такое enum, raw value и associated value в Swift?

Enum (перечисление) позволяет группировать связанные значения под общим типом с возможностью проверки типа. Raw value представляет постоянное значение каждого случая enum, например, строки или числа. Associated values позволяют хранить дополнительные пользовательские данные для каждого случая enum, поддерживая разные типы данных для разных случаев enum.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Как расшифровывается СA?

Расшифровывается как Core Animation. Это фреймворк, используемый в iOS и macOS для создания анимаций. Core Animation предоставляет высокоуровневый API для работы с анимациями, которые могут быть применены к слоям (CALayer). Он позволяет разработчикам создавать плавные и эффективные анимации с минимальными усилиями.

🚩Возможности

🟠Основные анимации (CABasicAnimation)
Анимация изменения свойств слоя, таких как позиция, масштаб, поворот, прозрачность и т.д.
🟠Ключевые кадры (CAKeyframeAnimation)
Создание сложных анимаций с использованием ключевых кадров, позволяющих анимировать свойства слоя по нескольким значениям.
🟠Групповые анимации (CAAnimationGroup)
Одновременное выполнение нескольких анимаций, объединенных в одну группу.
🟠Переходы (CATransition)
Анимация переходов между состояниями слоев, таких как изменение содержимого или структуры слоя.
🟠Слоистая модель (CALayer)
Core Animation основывается на слоях (CALayer), которые представляют собой абстракцию для управления графическим содержимым и анимациями.

🚩Пример использования

Основная анимация (CABasicAnimation)

import UIKit

class AnimationViewController: UIViewController {
    let animatedLayer = CALayer()

    override func viewDidLoad() {
        super.viewDidLoad()
        
        // Настройка слоя
        animatedLayer.frame = CGRect(x: 50, y: 50, width: 100, height: 100)
        animatedLayer.backgroundColor = UIColor.blue.cgColor
        self.view.layer.addSublayer(animatedLayer)
        
        // Создание анимации перемещения
        let animation = CABasicAnimation(keyPath: "position")
        animation.fromValue = CGPoint(x: 50, y: 50)
        animation.toValue = CGPoint(x: 300, y: 300)
        animation.duration = 2.0
        
        // Добавление анимации к слою
        animatedLayer.add(animation, forKey: "positionAnimation")
        
        // Обновление конечного состояния слоя
        animatedLayer.position = CGPoint(x: 300, y: 300)
    }
}

CAKeyframeAnimation

import UIKit

class KeyframeAnimationViewController: UIViewController {
    let animatedLayer = CALayer()

    override func viewDidLoad() {
        super.viewDidLoad()
        
        // Настройка слоя
        animatedLayer.frame = CGRect(x: 50, y: 50, width: 100, height: 100)
        animatedLayer.backgroundColor = UIColor.red.cgColor
        self.view.layer.addSublayer(animatedLayer)
        
        // Создание анимации ключевых кадров
        let keyframeAnimation = CAKeyframeAnimation(keyPath: "position")
        keyframeAnimation.values = [
            CGPoint(x: 50, y: 50),
            CGPoint(x: 150, y: 150),
            CGPoint(x: 250, y: 50),
            CGPoint(x: 300, y: 300)
        ]
        keyframeAnimation.duration = 4.0
        
        // Добавление анимации к слою
        animatedLayer.add(keyframeAnimation, forKey: "positionKeyframeAnimation")
        
        // Обновление конечного состояния слоя
        animatedLayer.position = CGPoint(x: 300, y: 300)
    }
}

Ставь 👍 и забирай 📚 Базу знаний

🤔 Что такое синхронная задача?

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

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Если обозначить внутри метода Synchronized , что будет монитору?

Это высокоуровневый механизм синхронизации, который объединяет взаимное исключение (mutex) и условные переменные (condition variables) для управления доступом к объектам в многопоточной среде.

🚩Как работает

🟠Взаимное исключение (Mutual Exclusion)
Только один поток может выполнить защищенный блок кода в любой момент времени.
🟠Условные переменные (Condition Variables)
Позволяют потокам ожидать определенных условий, а другим потокам уведомлять их о наступлении этих условий.

🚩Примеры

class ThreadSafeClass {
    private var internalState = 0
    private let queue = DispatchQueue(label: "com.example.threadSafeQueue")
    
    func increment() {
        queue.sync {
            internalState += 1
        }
    }
    
    func getState() -> Int {
        return queue.sync {
            internalState
        }
    }
}

С NSLock

class ThreadSafeClass {
    private var internalState = 0
    private let lock = NSLock()
    
    func increment() {
        lock.lock()
        internalState += 1
        lock.unlock()
    }
    
    func getState() -> Int {
        lock.lock()
        let state = internalState
        lock.unlock()
        return state
    }
}

С objc_sync_enter и objc_sync_exit

class ThreadSafeClass: NSObject {
    private var internalState = 0
    
    func increment() {
        objc_sync_enter(self)
        internalState += 1
        objc_sync_exit(self)
    }
    
    func getState() -> Int {
        objc_sync_enter(self)
        let state = internalState
        objc_sync_exit(self)
        return state
    }
}

Ставь 👍 и забирай 📚 Базу знаний

🤔 В чем разница между open и public в Swift?

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

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Можем ли на переменную "повесить" Synchronized?

В отличие от некоторых других языков, таких как Java, нет прямого способа "повесить" синхронизацию на отдельную переменную с использованием ключевого слова synchronized. Вместо этого, синхронизация осуществляется на уровне методов или блоков кода, которые обращаются к переменной. Это достигается использованием механизмов синхронизации, таких как NSLock, DispatchQueue, или атомарные переменные.

🚩Примеры

🟠C `NSLock`
В данном примере, доступ к переменной _value синхронизирован с помощью NSLock, что предотвращает одновременное чтение и запись из нескольких потоков.

class ThreadSafeVariable {
    private var _value: Int = 0
    private let lock = NSLock()
    
    var value: Int {
        get {
            lock.lock()
            let v = _value
            lock.unlock()
            return v
        }
        set {
            lock.lock()
            _value = newValue
            lock.unlock()
        }
    }
}

🟠C `DispatchQueue`
В этом примере, доступ к переменной _value осуществляется через серийную очередь, что обеспечивает эксклюзивный доступ к переменной в любой момент времени.

class ThreadSafeVariable {
    private var _value: Int = 0
    private let queue = DispatchQueue(label: "com.example.threadSafeQueue")
    
    var value: Int {
        get {
            return queue.sync {
                _value
            }
        }
        set {
            queue.sync {
                _value = newValue
            }
        }
    }
}

🚩C использованием атомарных переменных
Здесь используется атомарная переменная ManagedAtomic для обеспечения безопасного доступа к переменной _value.

import Atomics

class ThreadSafeVariable {
    private var _value = ManagedAtomic(0)
    
    var value: Int {
        get {
            return _value.load(ordering: .relaxed)
        }
        set {
            _value.store(newValue, ordering: .relaxed)
        }
    }
}

Ставь 👍 и забирай 📚 Базу знаний

🤔 Зачем нужен тип ссылок unowned в Swift?

Unowned ссылки используются для предотвращения сильных циклов ссылок (retain cycles) между экземплярами классов, когда два объекта ссылаются друг на друга сильно. В отличие от `weak`, `unowned` не делает объект опциональным и не автоматически обнуляется, что делает его подходящим для случаев, когда другой объект гарантированно будет иметь тот же или более долгий срок жизни.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Что такое Object?

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

🚩Характеристики

🟠Состояние (State)
Представлено данными или свойствами (properties) объекта. Например, объект Car может иметь свойства color, model, и year.
🟠Поведение (Behavior)
Определяется методами (methods) объекта. Например, объект Car может иметь методы drive() и brake().
🟠Идентичность (Identity)
Каждый объект имеет уникальную идентичность, которая отличает его от других объектов, даже если их состояния идентичны.

🚩Объекты и классы

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

class Car {
    var color: String
    var model: String
    var year: Int
    
    init(color: String, model: String, year: Int) {
        self.color = color
        self.model = model
        self.year = year
    }
    
    func drive() {
        print("The \(color) \(model) is driving.")
    }
    
    func brake() {
        print("The \(color) \(model) is braking.")
    }
}

Создание объекта:

let myCar = Car(color: "Red", model: "Toyota", year: 2020)
myCar.drive()
myCar.brake()

🚩Примеры использования

🟠Инкапсуляция (Encapsulation)
Объекты скрывают детали реализации и предоставляют интерфейс для взаимодействия. Это способствует защите данных и улучшению модульности.
🟠Наследование (Inheritance)
Объекты могут наследовать свойства и методы от других классов, позволяя создавать иерархии классов и повторно использовать код.
🟠Полиморфизм (Polymorphism)
Объекты могут быть обработаны через интерфейсы или базовые классы, что позволяет использовать один и тот же код для объектов разных типов.

🚩Пример инкапсуляции

В этом примере, свойство age скрыто от внешнего доступа, и доступ к нему осуществляется через методы getAge и setAge.

class Person {
    private var age: Int
    
    init(age: Int) {
        self.age = age
    }
    
    func getAge() -> Int {
        return age
    }
    
    func setAge(newAge: Int) {
        if newAge > 0 {
            age = newAge
        }
    }
}

let person = Person(age: 25)
print(person.getAge())  // 25
person.setAge(newAge: 30)
print(person.getAge())  // 30

Ставь 👍 и забирай 📚 Базу знаний

🤔 Какие можешь выделить главные принципы ООП?

Основные принципы объектно-ориентированного программирования (ООП) включают:
1. Инкапсуляция: сокрытие внутренних деталей реализации объекта и объединение данных и методов, работающих с этими данными, в один объект.
2. Наследование: создание нового класса на основе существующего.
3. Полиморфизм: возможность обращаться с объектами, производными от одного базового класса, для выполнения методов, определенных в базовом классе, но переопределенных в производных.
4. Абстракция: определение интерфейса взаимодействия с объектом, отделяющего его функциональное поведение от конкретной реализации.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 В какой момент создается Object?

Объект создается в момент инициализации экземпляра класса. В языке Swift это происходит при вызове конструктора (initializer) класса с использованием ключевого слова init. Когда инициализатор вызывается, выделяется память для объекта, и его свойства устанавливаются значениями, указанными в инициализаторе.

🚩Процесс создания объекта

1⃣Выделение памяти
Память для нового объекта выделяется в heap (куче).
2⃣Инициализация свойств
Все свойства объекта инициализируются значениями, указанными в конструкторе.
3⃣Вызов конструктора
Конструктор устанавливает начальное состояние объекта.

🚩Пример

class Car {
    var color: String
    var model: String
    var year: Int
    
    init(color: String, model: String, year: Int) {
        self.color = color
        self.model = model
        self.year = year
    }
    
    func drive() {
        print("The \(color) \(model) is driving.")
    }
    
    func brake() {
        print("The \(color) \(model) is braking.")
    }
}

🚩Создание объекта

let myCar = Car(color: "Red", model: "Toyota", year: 2020)

1⃣Выделение памяти
Память для объекта myCar выделяется в heap.
2⃣Инициализация свойств
Свойства color, model и year инициализируются значениями "Red", "Toyota" и 2020 соответственно.
3⃣Вызов конструктора
Инициализатор init(color:model:year:) устанавливает эти значения.

🚩Виды инициализаторов

🟠Назначенные инициализаторы (Designated Initializers)
Основные инициализаторы, которые инициализируют все свойства объекта.
🟠Удобные инициализаторы (Convenience Initializers)
Вспомогательные инициализаторы, которые вызывают другой инициализатор и могут задавать дополнительные параметры.

class Car {
    var color: String
    var model: String
    var year: Int
    
    init(color: String, model: String, year: Int) {
        self.color = color
        self.model = model
        self.year = year
    }
    
    convenience init(model: String) {
        self.init(color: "White", model: model, year: 2020)
    }
}

let defaultCar = Car(model: "Honda")

Ставь 👍 и забирай 📚 Базу знаний

🤔 Чем отличается frame от bounds?

Frame определяет положение и размер view относительно его родительской view, используя координаты родителя. Bounds описывает размеры и положение внутренней области view, используя собственные координаты, начиная от точки (0,0).

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Что такое companion object?

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

🚩Companion Object

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

class MyClass {
    companion object {
        fun staticMethod() {
            println("This is a static method")
        }
    }
}

// Вызов метода без создания экземпляра класса
MyClass.staticMethod()

🚩Аналог в Swift

В Swift статические члены класса (свойства и методы) определяются с использованием ключевого слова static. Статические члены принадлежат самому классу, а не его экземплярам.

class MyClass {
    static func staticMethod() {
        print("This is a static method")
    }
}

// Вызов метода без создания экземпляра класса
MyClass.staticMethod()

🚩Свойства и методы класса

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

class MyClass {
    class func classMethod() {
        print("This is a class method")
    }
}

class SubClass: MyClass {
    override class func classMethod() {
        print("This is an overridden class method")
    }
}

// Вызов метода без создания экземпляра класса
MyClass.classMethod()   // Output: This is a class method
SubClass.classMethod()  // Output: This is an overridden class method

Ставь 👍 и забирай 📚 Базу знаний

🤔 В чем разница между MVC и MVVM

MVC (Model-View-Controller) и MVVM (Model-View-ViewModel) — это архитектурные шаблоны для организации кода, но они различаются подходом к связи компонентов. В MVC контроллер управляет взаимодействием между моделью и представлением, а представление напрямую зависит от контроллера, что упрощает структуру, но может усложнять тестирование. В MVVM модель представления (ViewModel) связывается с представлением через механизм привязки данных, что делает его более удобным для двусторонней связи и улучшает тестируемость и поддерживаемость, особенно в приложениях с пользовательским интерфейсом, например, на Android или WPF.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Если внутри класса добавить object и companion object, какая между ними разница?

🚩Обычный объект внутри класса

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

class MyClass {
    let instanceProperty = "Instance Property"
    
    struct MyObject {
        static let objectProperty = "Object Property"
        
        static func objectMethod() {
            print("This is an object method")
        }
    }
}

// Использование
let myClassInstance = MyClass()
print(MyClass.MyObject.objectProperty) // Доступ к свойствам и методам объекта через имя объекта
MyClass.MyObject.objectMethod()

Companion Object (компаньон-объект)
Companion object позволяет определить статические члены класса. Эти члены доступны без создания экземпляра класса. Вы можете использовать companion object для хранения статических методов и свойств, которые могут быть вызваны напрямую через имя класса.

class MyClass {
    let instanceProperty = "Instance Property"
    
    companion object {
        let companionProperty = "Companion Property"
        
        func companionMethod() {
            print("This is a companion object method")
        }
    }
}

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

🚩Основные различия

🟠Доступность
Обычный объект: Доступ к свойствам и методам обычного объекта осуществляется через его имя. Companion Object: Доступ к свойствам и методам компаньон-объекта осуществляется через имя класса.

🟠Использование в контексте экземпляров класса
Обычный объект: Не привязан к конкретному экземпляру класса и создается один раз для всего класса. Companion Object: Также не привязан к конкретному экземпляру класса и создается один раз для всего класса, но служит для определения статических членов класса.

🟠Неявное имя
Обычный объект: Требует явного имени для доступа. Companion Object: Имеет неявное имя Companion, если не указано другое имя. Это позволяет получить доступ к его членам без явного указания имени.

🚩Пример использования и различий

class MyClass {
    val instanceProperty = "Instance Property"
    
    object MyObject {
        val objectProperty = "Object Property"
        
        fun objectMethod() {
            println("This is an object method")
        }
    }
    
    companion object {
        val companionProperty = "Companion Property"
        
        fun companionMethod() {
            println("This is a companion object method")
        }
    }
}

// Доступ к свойствам и методам объекта через имя объекта
println(MyClass.MyObject.objectProperty)
MyClass.MyObject.objectMethod()

// Доступ к свойствам и методам компаньон-объекта через имя класса
println(MyClass.companionProperty)
MyClass.companionMethod()

Ставь 👍 и забирай 📚 Базу знаний

🤔 Что такое ARC?

ARC (Automatic Reference Counting) — это система управления памятью, используемая в Swift и Objective-C, которая автоматически управляет жизненным циклом объектов. ARC отслеживает, сколько ссылок (или "счетчиков ссылок") указывает на объект, и освобождает его из памяти, когда счетчик достигает нуля. Это помогает предотвратить утечки памяти, хотя циклические ссылки всё равно могут требовать ручного разрыва.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Что ближе к модулю у тебя?

Модуль в iOS-разработке представляет собой логически изолированную часть приложения, включающую все необходимые компоненты для выполнения определённой функции. Вот пример модуля User с использованием архитектурного шаблона VIPER:

🚩Пример структуры модуля `User`

- Modules
  - User
    - View
      - UserView.swift
      - UserViewController.swift
    - Interactor
      - UserInteractor.swift
    - Presenter
      - UserPresenter.swift
    - Entity
      - UserEntity.swift
    - Router
      - UserRouter.swift

🚩Пример кода для модуля `User`

UserView.swift

import UIKit

protocol UserViewProtocol: AnyObject {
    var presenter: UserPresenterProtocol? { get set }
    func showUserData(_ user: UserEntity)
}

class UserView: UIViewController, UserViewProtocol {
    var presenter: UserPresenterProtocol?

    override func viewDidLoad() {
        super.viewDidLoad()
        presenter?.viewDidLoad()
    }

    func showUserData(_ user: UserEntity) {
        // Обновление UI с данными пользователя
    }
}

UserInteractor.swift

protocol UserInteractorProtocol: AnyObject {
    var presenter: UserPresenterProtocol? { get set }
    func fetchUserData()
}

class UserInteractor: UserInteractorProtocol {
    weak var presenter: UserPresenterProtocol?

    func fetchUserData() {
        let user = UserEntity(name: "John Doe", age: 30)
        presenter?.didFetchUserData(user)
    }
}

UserPresenter.swift

protocol UserPresenterProtocol: AnyObject {
    var view: UserViewProtocol? { get set }
    var interactor: UserInteractorProtocol? { get set }
    var router: UserRouterProtocol? { get set }
    func viewDidLoad()
    func didFetchUserData(_ user: UserEntity)
}

class UserPresenter: UserPresenterProtocol {
    weak var view: UserViewProtocol?
    var interactor: UserInteractorProtocol?
    var router: UserRouterProtocol?

    func viewDidLoad() {
        interactor?.fetchUserData()
    }

    func didFetchUserData(_ user: UserEntity) {
        view?.showUserData(user)
    }
}

UserEntity.swift

struct UserEntity {
    let name: String
    let age: Int
}

UserRouter.swift

protocol UserRouterProtocol: AnyObject {
    static func createModule() -> UIViewController
}

class UserRouter: UserRouterProtocol {
    static func createModule() -> UIViewController {
        let view = UserView()
        let presenter: UserPresenterProtocol & UserInteractorOutputProtocol = UserPresenter()
        let interactor: UserInteractorProtocol = UserInteractor()
        let router: UserRouterProtocol = UserRouter()

        view.presenter = presenter
        presenter.view = view
        presenter.interactor = interactor
        presenter.router = router
        interactor.presenter = presenter

        return view
    }
}

Ставь 👍 и забирай 📚 Базу знаний

🤔 Расскажи об MVVM

MVVM (Model-View-ViewModel) — это архитектурный паттерн, часто используемый в разработке UI-приложений, где Model управляет данными, View отвечает за представление, а ViewModel связывает данные с представлением. ViewModel содержит логику и данные, необходимые для отображения в View, и часто использует привязку данных, чтобы автоматически обновлять интерфейс при изменении данных. Этот паттерн помогает разделить логику приложения и интерфейс, облегчая поддержку и тестирование кода.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Где храните Pod'ы?

В iOS-проектах обычно хранятся и управляются с помощью CocoaPods, популярного менеджера зависимостей для проектов на Swift и Objective-C. Вот основные моменты и шаги, связанные с хранением и управлением Pod'ами:

🚩Шаги

1⃣Установка CocoaPods
Установите CocoaPods, если он ещё не установлен, используя команду

sudo gem install cocoapods     

2⃣Создание Podfile
Перейдите в корневую директорию вашего проекта и создайте Podfile, если он ещё не создан, используя команду

pod init     

3⃣Конфигурация Podfile
Откройте Podfile и добавьте необходимые зависимости. Например:

platform :ios, '13.0'

target 'YourApp' do
  use_frameworks!

  # Подключение библиотек
  pod 'Alamofire', '~> 5.4'
  pod 'SwiftyJSON', '~> 5.0'
 end     

4⃣Установка Pod'ов
Установите Pod'ы, используя команду

pod install     

5⃣Открытие .xcworkspace
После установки Pod'ов откройте сгенерированный файл .xcworkspace вместо .xcodeproj для работы с проектом

open YourApp.xcworkspace     

🚩Хранение Pod'ов

Pod'ы, указанные в Podfile, загружаются и устанавливаются в директорию Pods, которая создаётся в корневой директории вашего проекта. Также CocoaPods создаёт или обновляет несколько файлов, таких как Podfile.lock, Pods/Manifest.lock и YourApp.xcworkspace.

🟠`Pods/`
Директория, где хранятся все установленные зависимости и их файлы.
🟠`Podfile.lock`
Файл, фиксирующий версии всех установленных Pod'ов, чтобы обеспечить согласованность между разработчиками.
🟠`Pods/Manifest.lock`
Файл, используемый CocoaPods для синхронизации состояния Pod'ов.
🟠`YourApp.xcworkspace`
Рабочая область, которая объединяет ваш проект и его зависимости.

🚩Практики управления

1⃣Добавление `Podfile` и `Podfile.lock` в систему контроля версий
Добавьте Podfile и Podfile.lock в ваш репозиторий (например, Git), чтобы обеспечить согласованность зависимостей между разработчиками.

git add Podfile Podfile.lock
git commit -m "Add Podfile and Podfile.lock"     

2⃣Игнорирование директории `Pods/`
Обычно директорию Pods/ игнорируют в системе контроля версий, добавляя её в .gitignore.

Pods/     

3⃣Согласованность зависимостей
При клонировании репозитория или при изменении зависимостей выполните pod install, чтобы установить те же версии Pod'ов, что указаны в Podfile.lock.

Ставь 👍 и забирай 📚 Базу знаний

🤔 Какие есть паттерны в объектном проектировании

Среди паттернов объектного проектирования выделяются: порождающие паттерны (например, Singleton, Factory, Builder), структурные паттерны (Adapter, Composite, Decorator) и поведенческие паттерны (Observer, Strategy, Command). Порождающие паттерны помогают создавать объекты, структурные организуют отношения между объектами, а поведенческие управляют взаимодействиями и обязанностями объектов. Эти паттерны способствуют созданию гибкого и поддерживаемого кода.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний