🤔 Чем array отличается от list?

Array — это фиксированный по размеру массив элементов, а List — изменяемая или неизменяемая коллекция с гибкой длиной. Array удобен для высокопроизводительных операций с фиксированным числом элементов, а List предоставляет богатый функционал для работы с динамическими данными. В Kotlin List также может быть неизменяемым, что повышает безопасность кода.

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

🤔 В какой момент система может перезапустить сервис?

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

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

public class MyService extends Service {
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
// Выполнение задачи
return START_STICKY;
}

@Override
public IBinder onBind(Intent intent) {
return null;
}
}

🟠Использование `START_REDELIVER_INTENT`
Если сервис был запущен с использованием START_REDELIVER_INTENT, система также попытается перезапустить его, если он был убит, но с повторной доставкой последнего Intent. Это полезно для сервисов, которые должны обработать все интенты, даже если они были убиты и перезапущены.

public class MyService extends Service {
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
// Выполнение задачи
return START_REDELIVER_INTENT;
}

@Override
public IBinder onBind(Intent intent) {
return null;
}
}

🟠Использование Foreground Service
Foreground сервисы — это сервисы, которые пользователи знают, что они работают, и обычно показывают уведомление. Такие сервисы имеют более высокий приоритет и менее вероятно будут убиты системой. Однако, если это произойдет, система постарается их перезапустить.

public class MyForegroundService extends Service {
@Override
public void onCreate() {
super.onCreate();
// Создание уведомления
Notification notification = new NotificationCompat.Builder(this, CHANNEL_ID)
.setContentTitle("Foreground Service")
.setContentText("Service is running")
.setSmallIcon(R.drawable.ic_service)
.build();

// Запуск сервиса переднего плана
startForeground(1, notification);
}

@Override
public int onStartCommand(Intent intent, int flags, int startId) {
// Выполнение задачи
return START_STICKY;
}

@Override
public IBinder onBind(Intent intent) {
return null;
}
}

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

🤔 В чем отличие между job и supervisor job?

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

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

🤔 Что будет со старым Activity, когда система запустит новое?

Когда система запускает новое Activity в Android, судьба старого Activity зависит от множества факторов, включая флаги намерения (intent flags), конфигурацию задачи (task configuration) и состояние памяти устройства.

🟠По умолчанию (без специальных флагов)
Если не используются специальные флаги или конфигурации, то при запуске нового Activity старое Activity остается в стеке задач (back stack).
Старое Activity переходит в состояние onPause(), затем onStop().
Новое Activity создается и проходит состояния onCreate(), onStart() и onResume().

Intent intent = new Intent(this, NewActivity.class);
startActivity(intent);

🟠Использование флага `FLAG_ACTIVITY_NEW_TASK`
Если флаг FLAG_ACTIVITY_NEW_TASK установлен, новое Activity запускается в новом отдельном стеке задач, если такого еще нет.
Старое Activity остается в своей задаче.
Новое Activity запускается в новой задаче.

Intent intent = new Intent(this, NewActivity.class);
intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
startActivity(intent);

🟠Использование флага `FLAG_ACTIVITY_CLEAR_TOP`
Если флаг FLAG_ACTIVITY_CLEAR_TOP установлен, новое Activity будет запускаться, а все активности над ним в стеке будут удалены.
Если старое Activity уже в стеке задач, все активности выше него будут удалены.
Старое Activity будет возвращено в состояние onRestart(), onStart() и onResume().

Intent intent = new Intent(this, NewActivity.class);
intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
startActivity(intent);

🟠Использование флага `FLAG_ACTIVITY_SINGLE_TOP`
Если флаг FLAG_ACTIVITY_SINGLE_TOP установлен и новое Activity уже находится на вершине стека, оно не будет пересоздано, а просто получит вызов onNewIntent().
Если новое Activity уже на вершине стека, его метод onNewIntent() будет вызван вместо создания нового экземпляра.

Intent intent = new Intent(this, NewActivity.class);
intent.addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP);
startActivity(intent);

🚩Сценарии работы с памятью

Если система нуждается в памяти, она может уничтожить старое Activity, которое находится в состоянии onStop(). Когда пользователь вернется к этому Activity, оно будет пересоздано и его метод onCreate() будет вызван снова.

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

🤔 Что является сущностью корутин контекста?

Основными сущностями корутинного контекста являются Job (управляет жизненным циклом), CoroutineDispatcher (определяет, на каком потоке выполняется корутина) и пользовательские элементы. Контекст передаёт данные и управляющие инструкции между корутинами. Это позволяет эффективно координировать выполнение задач.

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

🤔 Если Activity запускается после сервиса, можно ли подсоединиться к этому сервису?

Да, в Android можно подключиться к сервису после его запуска и взаимодействовать с ним через механизм привязки (binding). Это достигается с помощью метода bindService(). Привязка к сервису позволяет активити (или другому компоненту) взаимодействовать с уже запущенным сервисом, получать данные от него или отправлять команды.

🚩Шаги

1⃣Создание сервиса
Сначала создайте сервис, который можно будет запускать и к которому можно будет привязываться. В данном примере, используем BoundService.

2⃣Запуск сервиса
Запустите сервис с помощью метода startService().

3⃣Привязка к сервису
Используйте метод bindService() для подключения к уже запущенному сервису.

🚩Пример реализации

1⃣Создайте BoundService

public class MyBoundService extends Service {
private final IBinder binder = new LocalBinder();

public class LocalBinder extends Binder {
MyBoundService getService() {
return MyBoundService.this;
}
}

@Override
public IBinder onBind(Intent intent) {
return binder;
}

public String getGreeting() {
return "Hello from Bound Service!";
}
}

2⃣Запустите и привяжитесь к сервису в Activity

<LinearLayout xmlns:android="https://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical"
android:gravity="center"
android:padding="16dp">

<Button
android:id="@+id/button"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Get Greeting" />

<TextView
android:id="@+id/textView"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_marginTop="20dp"
android:textSize="18sp" />
</LinearLayout>

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

🤔 Расскажи про наследование в Kotlin?

Наследование в Kotlin используется для создания новых классов на основе существующих с помощью ключевого слова open. Базовый класс может быть расширен, а его методы и свойства переопределены в дочернем классе с помощью override. Это позволяет повторно использовать код и добавлять новую функциональность.

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

🤔 Как task manager передает результат?

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

🚩Передача результата с помощью `WorkManager`

1⃣Создание Worker
Создайте класс, который наследует Worker или CoroutineWorker, и определите работу, которую необходимо выполнить в методе doWork().

import android.content.Context
import androidx.work.Worker
import androidx.work.WorkerParameters
import androidx.work.Data

class MyWorker(context: Context, workerParams: WorkerParameters) : Worker(context, workerParams) {
    override fun doWork(): Result {
        // Выполните свою задачу
        val outputData = Data.Builder()
            .putString("key_result", "Task Completed Successfully")
            .build()
        
        // Возвращение результата
        return Result.success(outputData)
    }
}

2⃣Запуск задачи
Запланируйте и запустите задачу, используя WorkManager. Настройте WorkRequest и передайте данные, если это необходимо.

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import androidx.work.OneTimeWorkRequest
import androidx.work.WorkManager
import androidx.work.Data
import androidx.work.ExistingWorkPolicy

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        // Создание WorkRequest
        val workRequest = OneTimeWorkRequest.Builder(MyWorker::class.java)
            .build()

        // Запуск задачи
        WorkManager.getInstance(this).enqueue(workRequest)
    }
}

3⃣Наблюдение за результатами выполнения задачи
Используйте LiveData для наблюдения за статусом и результатами выполнения задачи. Это позволяет получать обновления о состоянии задачи в реальном времени.

import androidx.lifecycle.Observer
import androidx.work.WorkInfo

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        val workRequest = OneTimeWorkRequest.Builder(MyWorker::class.java).build()
        WorkManager.getInstance(this).enqueue(workRequest)

        // Наблюдение за результатами выполнения задачи
        WorkManager.getInstance(this).getWorkInfoByIdLiveData(workRequest.id)
            .observe(this, Observer { workInfo ->
                if (workInfo != null && workInfo.state.isFinished) {
                    if (workInfo.state == WorkInfo.State.SUCCEEDED) {
                        val outputData = workInfo.outputData
                        val result = outputData.getString("key_result")
                        // Обработка результата
                        println("Result: $result")
                    } else if (workInfo.state == WorkInfo.State.FAILED) {
                        // Обработка ошибки
                        println("Task Failed")
                    }
                }
            })
    }
}

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

🤔 Что знаешь о диспатчерах?

Диспетчеры в Kotlin определяют, на каком потоке будет выполняться корутина, например, Dispatchers.Main для UI-потока, Dispatchers.IO для ввода-вывода и Dispatchers.Default для фоновых вычислений. Они помогают распределять задачи по подходящим потокам, обеспечивая оптимальную производительность. Также можно создать собственный диспетчер для специфичных задач.

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

🤔 Как можно получить сообщения на главном потоке с помощью Handler и Looper?

В Android для обработки сообщений и выполнения задач в основном (главном) потоке часто используются классы Handler и Looper. Handler позволяет отправлять и обрабатывать Message и Runnable объекты, ассоциированные с Looper. Главный поток приложения имеет свой Looper, который постоянно обрабатывает очередь сообщений и задач.

🚩Основные шаги для использования

1⃣Создание Handler
В главном потоке Handler можно создавать непосредственно, так как Looper уже существует. Это можно сделать в любом месте, например, в Activity или Fragment.

import android.os.Bundle;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import androidx.annotation.NonNull;
import androidx.appcompat.app.AppCompatActivity;

public class MainActivity extends AppCompatActivity {

    private Handler mainHandler;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // Создание Handler, привязанного к Looper главного потока
        mainHandler = new Handler(Looper.getMainLooper()) {
            @Override
            public void handleMessage(@NonNull Message msg) {
                // Обработка сообщений
                if (msg.what == 1) {
                    // Пример обработки сообщения
                    String messageData = (String) msg.obj;
                    System.out.println("Received message: " + messageData);
                }
            }
        };

        // Пример отправки сообщения
        Message message = Message.obtain();
        message.what = 1;
        message.obj = "Hello from background thread!";
        mainHandler.sendMessage(message);

        // Пример отправки задачи
        mainHandler.post(new Runnable() {
            @Override
            public void run() {
                System.out.println("Runnable executed on main thread");
            }
        });
    }
}

2⃣Отправка сообщений или задач на обработку в главный поток
Сообщения и задачи можно отправлять из любого потока. Например, из фонового потока:

new Thread(new Runnable() { 
    @Override
    public void run() {
        // Отправка сообщения
        Message message = Message.obtain();
        message.what = 1;
        message.obj = "Hello from background thread!";
        mainHandler.sendMessage(message);

        // Отправка задачи
        mainHandler.post(new Runnable() {
            @Override
            public void run() {
                System.out.println("Runnable executed on main thread from background thread");
            }
        });
    }
}).start();

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

🤔 Фреймворк Dagger

Dagger — это фреймворк для внедрения зависимостей в Java и Kotlin. Он использует аннотации для описания зависимостей и автоматического их создания. Dagger генерирует код на этапе компиляции, который управляет зависимостями и предоставляет их нуждающимся классам. Он основан на принципах инверсии управления и часто используется для масштабируемых приложений, таких как Android-приложения. В Android Dagger помогает удобно управлять зависимостями, улучшая тестируемость и читаемость кода.

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

🤔 Как Looper связывается с потоком?

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

1⃣Создание Looper
По умолчанию главный поток приложения уже имеет Looper, и мы можем получить его с помощью Looper.getMainLooper(). Для других потоков мы должны создать Looper вручную.

2⃣Подготовка Looper для потока
Метод Looper.prepare() создает Looper для текущего потока. Метод Looper.loop() запускает цикл обработки сообщений для этого Looper.

3⃣Создание Handler, связанного с Looper
Handler использует Looper, чтобы определять, к какому потоку привязан, и куда отправлять сообщения и задачи.

🚩Пример создания Looper в новом потоке

1⃣Создание Looper и Handler в новом потоке

public class LooperThread extends Thread {
    public Handler handler;
    private Looper looper;

    @Override
    public void run() {
        // Подготовка Looper для текущего потока
        Looper.prepare();

        // Создание Handler, связанного с этим Looper
        handler = new Handler(Looper.myLooper()) {
            @Override
            public void handleMessage(Message msg) {
                // Обработка сообщений
                System.out.println("Received message: " + msg.what);
            }
        };

        // Получение ссылки на Looper текущего потока
        looper = Looper.myLooper();

        // Запуск цикла обработки сообщений
        Looper.loop();
    }

    // Метод для остановки Looper
    public void quit() {
        if (looper != null) {
            looper.quit();
        }
    }
}

2⃣Использование LooperThread в Activity

import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import androidx.appcompat.app.AppCompatActivity;

public class MainActivity extends AppCompatActivity {
    private LooperThread looperThread;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // Запуск LooperThread
        looperThread = new LooperThread();
        looperThread.start();

        // Отправка сообщения в новый поток через Handler
        findViewById(R.id.button_send_message).setOnClickListener(view -> {
            if (looperThread.handler != null) {
                Message message = Message.obtain();
                message.what = 1;
                looperThread.handler.sendMessage(message);
            }
        });
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        // Остановка LooperThread
        looperThread.quit();
    }
}

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

🤔 Способы навигации в Kotlin

Jetpack Navigation Component — современный способ навигации, основанный на графе навигации и безопасных аргументах. Позволяет легко переходить между фрагментами и активностями, а также управлять состоянием навигации.
FragmentTransaction — ручной способ добавления, замены и удаления фрагментов.
Navigation через Intent — используется для переключения между активностями или фрагментами внутри приложения или между приложениями.
Explicit и Implicit Intents — явные и неявные намерения для навигации между компонентами.
NavHostFragment и NavController — связаны с использованием графа навигации для управления фрагментами в приложениях Android.

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

🤔 Как работает проверка на то, есть ли в потоке Looper?

Проверка на наличие Looper в потоке в Android осуществляется с помощью метода Looper.myLooper(). Метод Looper.myLooper()

public class LooperCheck {
    public static void main(String[] args) {
        // Проверка наличия Looper в главном потоке
        if (Looper.myLooper() != null) {
            System.out.println("Looper существует в текущем потоке.");
        } else {
            System.out.println("Looper не существует в текущем потоке.");
        }

        // Запуск нового потока без Looper
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                // Проверка наличия Looper в новом потоке
                if (Looper.myLooper() != null) {
                    System.out.println("Looper существует в новом потоке.");
                } else {
                    System.out.println("Looper не существует в новом потоке.");
                }

                // Создание Looper в новом потоке
                Looper.prepare();

                // Проверка снова после создания Looper
                if (Looper.myLooper() != null) {
                    System.out.println("Looper теперь существует в новом потоке.");
                } else {
                    System.out.println("Looper все еще не существует в новом потоке.");
                }

                // Запуск цикла обработки сообщений
                Looper.loop();
            }
        });

        thread.start();
    }
}

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

🤔 Data-классы в Kotlin

Data-классы в Kotlin — это классы, предназначенные для хранения данных. Они автоматически генерируют основные методы, такие как toString(), equals(), hashCode(), и copy(), упрощая работу с ними. Data-классы — это отличное решение, когда нужно хранить только данные, без логики, что делает код более чистым и понятным.

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

🤔 Как бы сконфигурировал ThreadPool для библиотеки аналитики?

Когда поток в Android разбирает пустую очередь сообщений с помощью Looper.loop(), он будет заблокирован и останется в состоянии ожидания до тех пор, пока не появится новое сообщение или задача в очереди. Это нормальное поведение для потоков с Looper, которые предназначены для обработки сообщений и задач асинхронно.

🚩Поведение `Looper.loop()` при пустой очереди

1⃣Создание и запуск `Looper`
Когда Looper.loop() вызывается, поток начинает обрабатывать сообщения и задачи из очереди, связанной с Looper.

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

3⃣Блокировка потока
Если очередь пуста, Looper вызывает метод MessageQueue.next() для получения следующего сообщения. Этот метод блокируется до тех пор, пока новое сообщение не станет доступным. Это означает, что поток будет находиться в состоянии ожидания и не будет потреблять значительное количество ресурсов, пока не появится новое сообщение.

🚩Пример работы с `Looper` и пустой очередью

public class LooperThread extends Thread {
    public Handler handler;

    @Override
    public void run() {
        // Подготовка Looper для текущего потока
        Looper.prepare();

        // Создание Handler, связанного с этим Looper
        handler = new Handler(Looper.myLooper()) {
            @Override
            public void handleMessage(Message msg) {
                // Обработка сообщений
                System.out.println("Received message: " + msg.what);
            }
        };

        // Запуск цикла обработки сообщений
        Looper.loop();
    }
}

public class MainActivity extends AppCompatActivity {
    private LooperThread looperThread;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // Запуск LooperThread
        looperThread = new LooperThread();
        looperThread.start();

        // Отправка сообщения в новый поток через Handler
        findViewById(R.id.button_send_message).setOnClickListener(view -> {
            if (looperThread.handler != null) {
                Message message = Message.obtain();
                message.what = 1;
                looperThread.handler.sendMessage(message);
            }
        });
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        // Остановка LooperThread
        looperThread.handler.getLooper().quit();
    }
}

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

🤔 Hilt для чего он используется?

Hilt — это библиотека для внедрения зависимостей в Android, построенная поверх Dagger. Она предоставляет простую настройку и интеграцию с Android-компонентами, такими как Activity, Fragment, ViewModel. Hilt автоматически управляет зависимостями и жизненным циклом компонентов, снижая сложность и уменьшая количество необходимого boilerplate-кода. Hilt особенно полезен для упрощения внедрения зависимостей в Android-приложениях.

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

🤔 Как делегаты работают на уровне компиляции Java ?

Позволяют переопределять поведение свойств, делегируя его другим объектам с помощью ключевого слова by. На уровне компиляции Java компилятор Kotlin генерирует вспомогательные классы и методы доступа, которые используют делегаты.

🚩Пример делегата

import kotlin.properties.Delegates

class Example {
    var p: String by Delegates.observable("<no name>") {
        prop, old, new -> println("$old -> $new")
    }
}

fun main() {
    val e = Example()
    e.p = "first"
    e.p = "second"
}

🚩Как это работает на уровне компиляции?

1⃣Вспомогательные классы
Компилятор создает классы для управления состоянием делегированных свойств.
2⃣Методы доступа
Создаются геттеры и сеттеры, использующие вспомогательные классы.
3⃣Вызов делегата
Внутри методов доступа добавляются вызовы делегата для управления значениями.

public final class Example {
    private final Delegates.Observable<String> p$delegate = Delegates.observable("<no name>", (property, oldValue, newValue) -> {
        System.out.println(oldValue + " -> " + newValue);
        return Unit.INSTANCE;
    });

    public final String getP() {
        return this.p$delegate.getValue(this, Example.class.getDeclaredField("p"));
    }

    public final void setP(String value) {
        this.p$delegate.setValue(this, Example.class.getDeclaredField("p"), value);
    }
}

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

🤔 Для чего нужен let?

Функция let в Kotlin используется для работы с объектами в безопасном контексте. Это позволяет выполнять операции над объектами, если они не равны null. Она часто используется для работы с nullable типами, позволяя избежать явных проверок на null. Внутри блока let объект доступен через it, что позволяет элегантно обрабатывать его.

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

🤔 Что быстрее, делегат или getter/setter ?

Когда речь идет о производительности, важно понимать, что делегаты и традиционные геттеры/сеттеры в Kotlin имеют разные цели и их производительность может зависеть от конкретного случая использования.

🚩Геттеры и сеттеры

Геттеры и сеттеры в Kotlin, как и в Java, это простые методы для получения и установки значений полей. Они имеют минимальный оверхед и выполняются очень быстро.

class Example {
    var value: String = ""
        get() = field
        set(value) {
            field = value
        }
}

🚩Делегаты

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

import kotlin.properties.Delegates

class Example {
    var value: String by Delegates.observable("<no name>") {
        prop, old, new ->
        println("$old -> $new")
    }
}

🚩Сравнение производительности

🟠Геттеры и сеттеры
Минимальный оверхед, высокая производительность.
Ограниченная функциональность, жестко заданное поведение.
🟠Делегаты
Гибкость, возможность добавления дополнительной логики.
Больший оверхед из-за дополнительной логики и вызовов.

fun main() {
    val exampleWithGetterSetter = ExampleGetterSetter()
    val exampleWithDelegate = ExampleDelegate()

    val iterations = 1_000_000

    // Тест геттеров и сеттеров
    var startTime = System.nanoTime()
    for (i in 0 until iterations) {
        exampleWithGetterSetter.value = "value"
        val value = exampleWithGetterSetter.value
    }
    var endTime = System.nanoTime()
    println("Getter/Setter time: ${(endTime - startTime) / 1_000_000} ms")

    // Тест делегатов
    startTime = System.nanoTime()
    for (i in 0 until iterations) {
        exampleWithDelegate.value = "value"
        val value = exampleWithDelegate.value
    }
    endTime = System.nanoTime()
    println("Delegate time: ${(endTime - startTime) / 1_000_000} ms")
}

class ExampleGetterSetter {
    var value: String = ""
        get() = field
        set(value) {
            field = value
        }
}

class ExampleDelegate {
    var value: String by Delegates.observable("<no name>") {
        prop, old, new -> // Нет дополнительной логики для чистоты эксперимента
    }
}

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