🤔 Что делает Unowned?

Это ключевое слово, которое используется для создания неустранимых ссылок. Неустранимая ссылка (unowned) не увеличивает счётчик ссылок на объект, к которому она относится, и, в отличие от слабых ссылок (weak), не обнуляется автоматически, когда объект освобождается из памяти. Использование unowned ссылок полезно в тех случаях, когда вы уверены, что объект, на который ссылается unowned ссылка, будет существовать на протяжении всей жизни ссылки.

🚩Особенности

🟠Не увеличивает счётчик ссылок
Unowned ссылки не удерживают объект в памяти, что предотвращает циклические ссылки.
🟠Не обнуляется автоматически
Если объект, на который ссылается unowned ссылка, освобождается из памяти, попытка доступа к этой ссылке приведёт к ошибке времени выполнения (runtime crash).
🟠Использование в ситуациях гарантированного существования
Unowned ссылки следует использовать только тогда, когда вы уверены, что объект будет существовать на протяжении всей жизни ссылки.

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

class Person {
    var name: String
    var creditCard: CreditCard?
    
    init(name: String) {
        self.name = name
    }
    
    deinit {
        print("\(name) is being deinitialized")
    }
}

class CreditCard {
    var number: Int
    unowned var owner: Person
    
    init(number: Int, owner: Person) {
        self.number = number
        self.owner = owner
    }
    
    deinit {
        print("CreditCard #\(number) is being deinitialized")
    }
}

var john: Person? = Person(name: "John")
john!.creditCard = CreditCard(number: 1234, owner: john!)

john = nil
// Output:
// John is being deinitialized
// CreditCard #1234 is being deinitialized

1⃣Создаётся объект Person с именем "John".
2⃣Создаётся объект CreditCard, который имеет unowned ссылку owner на john.
3⃣Когда объект john освобождается (при присвоении nil), также освобождается и объект CreditCard. Случаи использования unowned

🚩Когда использовать

🟠Гарантированное существование объекта
Вы уверены, что объект будет существовать на протяжении всей жизни ссылки.
🟠Избежание ненужной опциональности: Если объект гарантированно существует, использование unowned позволяет избежать использования опционалов (Optional), что упрощает код.

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

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

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

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

🤔 Как работает UITableView?

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

🚩Компоненты

🟠Data Source (Источник данных)
tableView(_:numberOfRowsInSection:): Количество строк.
tableView(_:cellForRowAt:): Конфигурация ячеек.
🟠Delegate (Делегат)
tableView(_:didSelectRowAt:): Обработка выбора строки.
tableView(_:heightForRowAt:): Настройка высоты строки.
🟠Cells (Ячейки)
Ячейки (UITableViewCell) отображают контент.

🚩Настройка `UITableView`

1⃣Создание проекта и добавление таблицы
Добавьте UITableView в ViewController через Interface Builder или программно. Подключите UITableView как IBOutlet.
2⃣Настройка Data Source и Delegate
Назначьте ViewController источником данных и делегатом таблицы. Реализуйте методы протоколов.

import UIKit

class ViewController: UIViewController, UITableViewDataSource, UITableViewDelegate {
    @IBOutlet weak var tableView: UITableView!

    override func viewDidLoad() {
        super.viewDidLoad()
        tableView.dataSource = self
        tableView.delegate = self
        tableView.register(UITableViewCell.self, forCellReuseIdentifier: "cell")
    }

    func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
        return 1000 // Количество строк
    }

    func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
        let cell = tableView.dequeueReusableCell(withIdentifier: "cell", for: indexPath)
        cell.textLabel?.text = "Row \(indexPath.row)"
        return cell
    }

    func tableView(_ tableView: UITableView, didSelectRowAt indexPath: IndexPath) {
        print("Selected row: \(indexPath.row)")
    }
}

🟠Повторное использование ячеек
Используйте dequeueReusableCell(withIdentifier:for:) для повторного использования ячеек.

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

🤔 Жизненный цикл UIViewController

Жизненный цикл UIViewController включает несколько ключевых этапов:
1. `loadView` создает представление, которое контроллер управляет.
2. `viewDidLoad` вызывается после загрузки представления контроллера в память.
3. `viewWillAppear` выполняется перед тем, как представление станет видимым.
4. `viewDidAppear` вызывается после того, как представление появилось на экране.
5. `viewWillDisappear` и `viewDidDisappear` вызываются перед и после того, как представление было удалено с экрана.
6. `deinit` вызывается перед освобождением экземпляра контроллера из памяти.

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

🤔 Как сделано VVM?

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

🚩Структура проекта

- Models
  - User.swift
- Views
  - UserView.swift
- ViewModels
  - UserViewModel.swift

🚩Полный пример реализации

🟠Model
Модель представляет данные и бизнес-логику. Например, это может быть структура User.

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

🟠ViewModel
ViewModel связывает модель и представление, управляя состоянием и логикой представления. Он использует @Published для обновления представления при изменении данных.

import Combine

class UserViewModel: ObservableObject {
    @Published var user: User?
    
    func fetchUser() {
        // Логика получения данных пользователя (например, из сети или базы данных)
        self.user = User(name: "John Doe", age: 30)
    }
}

🟠View
Представление отвечает за отображение данных и взаимодействие с пользователем. В SwiftUI представление использует @StateObject или @ObservedObject для наблюдения за изменениями данных в ViewModel.

import SwiftUI

struct UserView: View {
    @StateObject var viewModel = UserViewModel()
    
    var body: some View {
        VStack {
            if let user = viewModel.user {
                Text("Name: \(user.name)")
                Text("Age: \(user.age)")
            } else {
                Text("Loading...")
            }
        }
        .onAppear {
            viewModel.fetchUser()
        }
    }
}

struct UserView_Previews: PreviewProvider {
    static var previews: some View {
        UserView()
    }
}

🚩Полный пример

User.swift

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

UserViewModel.swift

import Combine

class UserViewModel: ObservableObject {
    @Published var user: User?
    
    func fetchUser() {
        // Логика получения данных пользователя (например, из сети или базы данных)
        self.user = User(name: "John Doe", age: 30)
    }
}

UserView.swift

import SwiftUI

struct UserView: View {
    @StateObject var viewModel = UserViewModel()
    
    var body: some View {
        VStack {
            if let user = viewModel.user {
                Text("Name: \(user.name)")
                Text("Age: \(user.age)")
            } else {
                Text("Loading...")
            }
        }
        .onAppear {
            viewModel.fetchUser()
        }
    }
}

struct UserView_Previews: PreviewProvider {
    static var previews: some View {
        UserView()
    }
}

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

🤔 Что такое 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()

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