Для чего нужен Manifest ?
Спросят с вероятностью 33%

Файл AndroidManifest.xml играет роль центрального конфигурационного файла, который содержит важную информацию о приложении для Android системы. В нём объявляются основные компоненты приложения, требуемые разрешения, поддерживаемые устройственные конфигурации и другие метаданные. Вот несколько ключевых аспектов, для которых он необходим:

1️⃣Объявление компонентов приложения

Manifest файл используется для объявления компонентов приложения, таких как Activity, Service, BroadcastReceiver, и ContentProvider. Для каждого из этих компонентов можно указать дополнительные настройки, например, интент-фильтры для Activity, которые определяют, какие интенты они могут обрабатывать.

2️⃣Запрос системных разрешений

Для доступа к защищённым частям API и функционалу устройства, например, камере, списку контактов или геопозиции, приложению необходимо запрашивать соответствующие разрешения. В AndroidManifest.xml указываются эти разрешения с помощью элемента <uses-permission>.

3️⃣Определение уровня API

Можно указать минимальный и целевой уровень API Android, с которым совместимо приложение. Это позволяет системе предотвращать установку приложения на несовместимых устройствах и оптимизировать его поведение для устройств с разными версиями Android.

4️⃣Объявление библиотек

Если приложение использует специализированные библиотеки оборудования (например, OpenGL ES), в нем необходимо объявить соответствующие функции и требования к оборудованию с помощью элементов <uses-feature> и <uses-library>.

5️⃣Установка фильтров интентов (`<intent-filter>`)

Объявляют, какие действия, данные или категории интентов может принимать компонент, позволяя другим приложениям взаимодействовать с ним. Например, Activity может объявить, что оно способно обрабатывать интенты для просмотра веб-страниц.

6️⃣Конфигурация приложения

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

AndroidManifest.xml является ключевым файлом в Android-приложениях, который информирует систему о структуре приложения, его компонентах, требуемых разрешениях, поддерживаемых функциях и других важных настройках, необходимых для правильной интеграции приложения в экосистему Android.

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

🔐 База собесов | 🔐 База тестовых

Что известно про корутины ?
Спросят с вероятностью 33%

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

Основные характеристики и преимущества:

1️⃣Легковесность: Корутины позволяют запускать тысячи параллельных операций, потребляя гораздо меньше ресурсов по сравнению с традиционными потоками. Это достигается благодаря тому, что корутины не привязаны к системным потокам и могут переключаться между ними.

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

3️⃣Управление асинхронностью: Корутины предоставляют механизмы для управления асинхронными операциями, такие как отмена операций, тайм-ауты и обработка ошибок.

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

Ключевые компоненты:

✅Coroutine Scope — определяет контекст выполнения корутины, управляя её жизненным циклом.
✅Coroutine Context — содержит различные элементы, такие как диспетчеры, которые определяют, в каком потоке будет выполняться корутина.
✅Dispatchers — помогают управлять потоками, на которых выполняются корутины. Например, Dispatchers.IO предназначен для ввода-вывода, Dispatchers.Main используется для взаимодействия с пользовательским интерфейсом.
✅Builders — функции, которые используются для запуска корутин, такие как launch и async, последняя из которых позволяет получить результат асинхронной операции.

Пример:

import kotlinx.coroutines.*

fun main() = runBlocking { // Создает корутину верхнего уровня
    launch { // Запускает новую корутину внутри блока runBlocking
        delay(1000L) // Неблокирующая задержка на 1 секунду (1000 миллисекунд)
        println("World!") // Печать после задержки
    }
    println("Hello,") // runBlocking ждет, пока вложенная корутина не завершится
}

Этот код демонстрирует запуск корутины с использованием launch, которая выводит "Hello," немедленно, затем ждет секунду перед выводом "World!".

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

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

🔐 База собесов | 🔐 База тестовых

Как работает hashmap ?
Спросят с вероятностью 33%

HashMap — это структура данных, которая использует хеш-таблицу для хранения пар "ключ-значение". Она позволяет выполнять операции вставки, удаления и поиска элементов с почти постоянным временем выполнения, что делает её очень эффективной для определённых задач. Вот как она работает:

Основы работы

1️⃣Хеширование ключей: Каждый раз, когда добавляется новая пара "ключ-значение", HashMap использует хеш-функцию для вычисления хеш-кода ключа. Хеш-код затем используется для определения индекса в массиве, где будет храниться значение. Это позволяет быстро находить значения по ключам.

2️⃣Разрешение коллизий: Два разных ключа могут иметь одинаковый хеш-код или хеш-коды, которые приводят к одному и тому же индексу в массиве (это называется коллизией). HashMap разрешает такие коллизии, сохраняя эти элементы в одной "корзине" или "ячейке" в виде списка (до Java 8 использовались связанные списки, начиная с Java 8 — сбалансированные деревья при большом количестве коллизий в одной корзине).

3️⃣Вставка и поиск: При вставке нового элемента HashMap вычисляет индекс корзины для ключа и помещает значение в эту корзину. При поиске значения по ключу HashMap снова вычисляет индекс, находит соответствующую корзину и затем перебирает элементы в ней, чтобы найти нужное значение.

4️⃣Масштабирование: Когда количество элементов в HashMap достигает определённого порога заполнения (загрузки), размер массива увеличивается, и все существующие элементы перераспределяются в новом массиве. Это необходимо для поддержания эффективности операций вставки и поиска.

Представьте, что у вас есть HashMap, где ключи — это имена пользователей, а значения — это их email. Когда вы добавляете новую пару "ключ-значение" ("John Doe", "[email protected]"), HashMap выполняет следующие действия:

1️⃣Вычисляет хеш-код для "John Doe".
2️⃣Использует хеш-код, чтобы найти индекс корзины, где должен быть сохранён email.
3️⃣Добавляет "[email protected]" в корзину этого индекса.

Когда вы пытаетесь найти email по имени "John Doe", HashMap снова вычисляет хеш-код для "John Doe", находит соответствующую корзину и возвращает сохранённый в ней email.

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

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

🔐 База собесов | 🔐 База тестовых

Что известно про типы any, unit, nothing в Kotlin ?
Спросят с вероятностью 33%

Существуют специальные типы Any, Unit и Nothing, которые имеют уникальные цели и применения в языке программирования:

Any

Является корневым типом для всех ненулевых типов в Kotlin, аналогичным Object. Любой объект, за исключением null, наследуется от Any. Этот тип обычно используется там, где требуется представление любого возможного значения, за исключением null. Any определяет несколько базовых методов, таких как equals(), hashCode() и toString(), которые могут быть переопределены.

fun printAnyObject(obj: Any) {
    println(obj.toString())
}

Unit

Аналогичен void, но в отличие от void, он является полноценным объектом. Функции в Kotlin, которые не возвращают значимый результат, на самом деле возвращают Unit. Этот тип обычно используется для указания, что функция выполняет действие, но не возвращает значение. Хотя возвращаемый тип Unit обычно опускается, его можно указать явно.

fun printHello(): Unit {
    println("Hello, World!")
}

Nothing

Это тип, который не имеет значений. Он используется для обозначения "невозможности", то есть ситуаций, когда функция никогда корректно не завершает своё выполнение. Например, функция может вечно зацикливаться или всегда выбрасывать исключение. Его указание в качестве возвращаемого типа функции помогает понять, что эта точка кода недостижима.

fun failWithErrorMessage(message: String): Nothing {
    throw IllegalArgumentException(message)
}

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

✅Any — это базовый тип для всех объектов в Kotlin, кроме null.
✅Unit указывает, что функция не возвращает полезное значение, аналогично void в других языках программирования, но является объектом.
✅Nothing используется для обозначения "невозможности" выполнения кода после определённой точки, например, после выброса исключения.

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

🔐 База собесов | 🔐 База тестовых

Ребят, напоминаю, что все вопросы, которые здесь публикуются можно посмотреть списком вместе с видео-ответами на моем сайте easyoffer.ru

Зачем нужен класс nothing ?
Спросят с вероятностью 33%

Класс Nothing имеет уникальное и очень специфическое назначение. Он представляет тип, который не имеет значений и используется для обозначения операций, которые никогда не завершаются нормально. Вот несколько ключевых причин, почему данный тип полезен:

1️⃣Обозначение "недостижимого" кода

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

2️⃣Помощь в статическом анализе кода

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

3️⃣Улучшение читабельности и понимания кода

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

Рассмотрим функцию, которая используется для обработки ошибок и всегда выбрасывает исключение:

fun throwError(message: String): Nothing {
    throw IllegalArgumentException(message)
}

В этом случае он указывает, что после вызова throwError выполнение текущей функции не будет продолжено. Это позволяет компилятору правильно анализировать поток выполнения программы и разработчикам легче понять поведение кода.

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

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

🔐 База собесов | 🔐 База тестовых

Что из себя представляет retrofit ?
Спросят с вероятностью 13%

Retrofit — это типобезопасный HTTP-клиент, разработанный компанией Square. Этот инструмент предназначен для упрощения процесса отправки сетевых запросов к RESTful API и обработки ответов сервера. Он позволяет превратить ваш HTTP API в Java интерфейс, что делает код более читаемым и легко поддерживаемым.

Основные характеристики:

1️⃣Простота в использовании: Упрощает процесс взаимодействия с веб-сервисами, позволяя определять методы взаимодействия с API в виде интерфейсов.

2️⃣Преобразование данных: Автоматически обрабатывает данные запросов и ответов. Он может сериализовать отправляемые данные или другие форматы и десериализовать ответы API обратно в Java объекты с помощью конвертеров, таких как Gson, Jackson, или Moshi.

3️⃣Асинхронные и синхронные вызовы: Поддерживает как синхронные, так и асинхронные вызовы API. Это делает его удобным для выполнения сетевых запросов в фоновом режиме без блокировки основного потока пользовательского интерфейса.

4️⃣Настраиваемость: Благодаря использованию OkHttp в качестве сетевого клиента, Retrofit предлагает расширенные возможности по настройке HTTP-клиентов, включая кэширование, управление таймаутами и перехватчики для мониторинга запросов и ответов.

Как он работает:

Работает путем преобразования определенного интерфейса в вызовы API. Каждый метод интерфейса ассоциируется с HTTP-запросом через аннотации, которые указывают тип запроса (GET, POST, PUT, DELETE и т.д.) и параметры запроса.

Пример:

public interface MyApiService {
    @GET("users/list")
    Call<List<User>> listUsers();

    @POST("users/new")
    Call<User> createUser(@Body User user);
}

✅@GET и @POST — аннотации, определяющие HTTP-метод запроса.
✅listUsers() — метод, который будет выполнять GET-запрос.
✅createUser(@Body User user) — метод, который будет выполнять POST-запрос с объектом User в качестве тела запроса.

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

Для его использования, вам необходимо:
1️⃣Определить интерфейс с методами API и аннотациями Retrofit.
2️⃣Создать его экземпляр, указав базовый URL API и добавив конвертеры для сериализации данных.
3️⃣Создать объект вашего API-интерфейса через экземпляр Retrofit.
4️⃣Вызвать методы API-интерфейса для выполнения сетевых запросов.

Retrofit retrofit = new Retrofit.Builder()
    .baseUrl("https://api.example.com/")
    .addConverterFactory(GsonConverterFactory.create())
    .build();

MyApiService apiService = retrofit.create(MyApiService.class);

// Асинхронный вызов API
apiService.listUsers().enqueue(new Callback<List<User>>() {
    @Override
    public void onResponse(Call<List<User>> call, Response<List<User>> response) {
        if (response.isSuccessful()) {
            List<User> users = response.body();
            // Обработка списка пользователей
        }
    }

    @Override
    public void onFailure(Call<List<User>> call, Throwable t) {
        // Обработка ошибки
    }
});

Retrofit является одним из самых популярных и мощных инструментов для взаимодействия с RESTful API в экосистеме Android и Java, предоставляя простой, но мощный способ взаимодействия с сетевыми сервисами.

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

🔐 База собесов | 🔐 База тестовых

Как определяется приоритет приложений перед системой ?
Спросят с вероятностью 27%

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

1️⃣Foreground Activity

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

2️⃣Visible Activity

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

3️⃣Background Services

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

4️⃣Broadcast Receivers

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

5️⃣Cached Processes

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

Исключения и специальные случаи:

✅Foreground Services: Сервисы, объявленные как работающие на переднем плане (с использованием уведомления), имеют высокий приоритет, схожий с приоритетом активных Activity.
✅Ограничения для фоновой работы: Начиная с Android Oreo (API уровень 26), введены новые ограничения на фоновую работу приложений для улучшения производительности системы и увеличения времени работы от батареи. Это влияет на способы, которыми приложения могут выполнять фоновые задачи и службы.

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

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

🔐 База собесов | 🔐 База тестовых

👾 Ребят, напоминаю, у нас есть приватные группы где мы делимся реальными собеседованиями и тестовыми заданиями. Чтобы попасть в эти в группы воспользуйтесь ботами:
🤖 Доступ к базе собесов
🤖 Доступ к базе тестовых заданий

Что известно про ключевое слово Object в Kotlin ?
Спросят с вероятностью 27%

Ключевое слово object имеет несколько особенностей использования, делающих его уникальным элементом языка. Оно может использоваться для создания синглтонов, объектов без класса (анонимных объектов), и для реализации объектов-компаньонов. Рассмотрим каждое из этих применений:

1️⃣Синглтон

object позволяет легко создать синглтон - класс, экземпляр которого существует в единственном числе во всём приложении. Вместо обычного класса, объявленного через class, используется object. Компилятор Kotlin автоматически гарантирует, что экземпляр такого класса будет один.

object Singleton {
    var counter = 0
    fun increment() {
        counter++
    }
}

Здесь Singleton — это объект-синглтон, у которого можно обращаться к переменным и методам напрямую через его имя.

2️⃣Объекты-компаньоны (`companion object`)

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

class MyClass {
    companion object Factory {
        fun create(): MyClass = MyClass()
    }
}

Метод create() доступен для вызова через MyClass.create(), подобно статическому методу в Java.

3️⃣Объекты без класса (анонимные объекты, `object`)

Можно использовать для создания анонимных объектов (без указания имени класса), когда требуется реализация интерфейса или абстрактного класса без создания явного класса.

val listener = object : MouseAdapter() {
    override fun mouseClicked(e: MouseEvent) {
        // Обработка клика мыши
    }
}

Этот код создает объект, который является наследником MouseAdapter и переопределяет метод mouseClicked, не создавая при этом явно нового класса.

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

✅Объекты, объявленные через object, инициализируются лениво при первом обращении к ним.
✅Они могут наследовать другие классы и реализовывать интерфейсы.
✅В контексте объектов-компаньонов object позволяет дополнительно расширять функционал класса без необходимости наследования или паттерна "Decorator".

Ключевое слово object предоставляет мощный инструмент для организации кода, облегчая создание синглтонов, статических методов и анонимных классов.

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

🔐 База собесов | 🔐 База тестовых

Что такое SharedPreferences ?
Спросят с вероятностью 13%

SharedPreferences представляет собой механизм для хранения и извлечения простых данных в форме пар ключ-значение. Это один из самых простых способов сохранения небольших объемов данных, таких как пользовательские настройки или состояние приложения, которые должны быть сохранены между сессиями использования приложения. Подходят для сохранения приватных данных, доступных только внутри приложения.

Основные особенности:

1️⃣Простота использования: Предоставляют простой API для чтения и записи простых типов данных, таких как boolean, float, int, long и String.

2️⃣Частная доступность: Данные, сохраненные через него, доступны только приложению, которое их создало, если только не используется модификатор доступа MODE_WORLD_READABLE или MODE_WORLD_WRITEABLE, использование которых не рекомендуется по соображениям безопасности и они устарели начиная с API Level 17.

3️⃣Применение: Используется в основном для хранения настроек пользователя, таких как предпочтения в отображении или настройки функций приложения. Также может использоваться для хранения важных флагов состояния или маркеров выполнения.

Как работает SharedPreferences:

Чтобы его использовать, необходимо получить экземпляр SharedPreferences через метод getSharedPreferences(String name, int mode) для определенного файла настроек или getPreferences(int mode) для доступа к файлу настроек, который приватно связан с активностью.

Пример:

Запись данных:

SharedPreferences sharedPreferences = getSharedPreferences("MyPrefs", Context.MODE_PRIVATE);
SharedPreferences.Editor editor = sharedPreferences.edit();
editor.putString("username", "exampleUser");
editor.putInt("sessionCount", 5);
editor.apply(); // или editor.commit();

Чтение данных:

SharedPreferences sharedPreferences = getSharedPreferences("MyPrefs", Context.MODE_PRIVATE);
String username = sharedPreferences.getString("username", "defaultUser");
int sessionCount = sharedPreferences.getInt("sessionCount", 0);

✅apply() выполняет сохранение данных асинхронно и не блокирует поток, в котором был вызван, тогда как commit() сохраняет данные синхронно и возвращает boolean, который показывает, было ли сохранение успешным.

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

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

🔐 База собесов | 🔐 База тестовых

В чем разница между linked list и array list ?
Спросят с вероятностью 27%

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

Внутренняя реализация:

✅ArrayList основан на динамическом массиве. Это позволяет обеспечить быстрый доступ к элементам по индексу, поскольку адрес каждого элемента в памяти может быть вычислен напрямую. Однако, поскольку внутренний массив имеет фиксированный размер, при его переполнении необходимо выделить массив большего размера и скопировать в него все элементы из старого массива, что делает операции добавления и удаления более затратными по времени, особенно для больших объемов данных.
✅LinkedList основан на двусвязном списке элементов, где каждый элемент (узел) содержит данные и ссылки на предыдущий и следующий элементы в списке. Это обеспечивает высокую производительность операций вставки и удаления, поскольку требуется лишь изменить ссылки у соседних элементов, но доступ к элементам по индексу занимает больше времени, так как для этого нужно последовательно пройти от начала или конца списка до нужного элемента.

Производительность:

ArrayList:
✅Быстрый доступ к элементам по индексу.
✅Медленные операции добавления и удаления элементов (особенно в начале и середине списка), так как может потребоваться сдвиг оставшейся части массива.

LinkedList:
✅Быстрые операции вставки и удаления элементов, поскольку они требуют только изменения ссылок.
✅Медленный доступ к элементам по индексу, так как для доступа к элементу необходимо пройти по списку.

Использование памяти:

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

Идеальные сценарии использования:

✅ArrayList идеально подходит для сценариев, где требуются частые операции чтения.
✅LinkedList предпочтительнее использовать, когда приложение выполняет много операций вставки и удаления.

ArrayList и LinkedList обеспечивают различные производительности для операций чтения, вставки и удаления. Выбор между ними зависит от конкретных требований к производительности и типа операций, которые будут наиболее часто выполняться в вашем приложении.

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

🔐 База собесов | 🔐 База тестовых

Что известно про чистую архитектуру ?
Спросят с вероятностью 27%

Чистая архитектура (Clean Architecture) — это концепция в программной инженерии, предложенная Робертом Мартином (Uncle Bob), направленная на создание программного обеспечения, которое является устойчивым к изменениям, легко тестируемым, и может быть развёрнуто на разных платформах. Она стремится минимизировать зависимости между различными частями приложения, чтобы облегчить поддержку и обновление кода.

Данная архитектура основывается на нескольких основных принципах:

1️⃣Независимость от фреймворков: Архитектура не должна зависеть от библиотек или фреймворков, что позволяет использовать систему как набор инструментов, а не наоборот.
2️⃣Тестируемость: Бизнес-логика приложения должна быть изолирована от UI, баз данных и других внешних элементов, что облегчает тестирование.
3️⃣Независимость от UI: Интерфейс пользователя должен быть легко изменяем без внесения изменений в остальную систему.
4️⃣Независимость от базы данных: Бизнес-логика не должна зависеть от конкретной базы данных.
5️⃣Независимость от внешних агентов: Бизнес-правила не должны зависеть от внешних служб или систем.

Данная архитектура предлагает разделение системы на слои, где каждый слой имеет строго определенные обязанности и зависит только от слоёв, расположенных на более глубоком уровне:

✅Entities (Сущности): Содержат бизнес-правила приложения. Это могут быть объекты предметной области или данные, которые не зависят от использования конкретных технологий.
✅Use Cases (Сценарии использования): Содержат специфические бизнес-правила приложения и описывают, как и когда должны использоваться сущности.
✅Interface Adapters (Адаптеры интерфейсов): Преобразуют данные в удобный для сценариев использования и сущностей формат и наоборот. Этот слой отвечает за взаимодействие с базами данных, веб-сервисами и пользовательским интерфейсом.
✅Frameworks and Drivers (Фреймворки и драйверы): Внешний слой, который включает в себя все внешние компоненты, такие как базы данных, веб-фреймворки и библиотеки.

Основной целью чистой архитектуры является создание системы, которая:

✅Гибкая к изменениям: Легко адаптируется к изменениям в бизнес-требованиях или технологиях.
✅Легко тестируемая: Бизнес-логика отделена от внешних зависимостей.
✅Простая в поддержке: Зависимости между слоями минимизированы, что облегчает обновления и исправления.

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

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

🔐 База собесов | 🔐 База тестовых

Что такое BroadcastReceiver ?
Спросят с вероятностью 27%

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

Когда какое-то событие происходит, система или приложение может рассылать соответствующий "интент" (Intent) в виде широковещательного сообщения, которое будет получено всеми заинтересованными BroadcastReceiver'ами, зарегистрированными на прием таких сообщений.

Как он работает:

✅Объявление в манифесте: Вы можете объявить его в манифесте вашего приложения, указав те интенты, на которые он должен реагировать. Это делает его доступным даже если ваше приложение не запущено.

✅Динамическая регистрация: Вы также можете зарегистрировать его динамически в коде вашего приложения. В этом случае он будет получать сообщения только когда ваше приложение запущено и активно.

Пример:
Давайте рассмотрим простой пример, где мы создаем BroadcastReceiver для прослушивания изменений состояния подключения к сети:

class NetworkChangeReceiver : BroadcastReceiver() {
    override fun onReceive(context: Context?, intent: Intent?) {
        val isConnected = /* Проверьте состояние сети */
        if (isConnected) {
            // Действия при подключении к сети
        } else {
            // Действия при отключении от сети
        }
    }
}

Если вы объявляете BroadcastReceiver в манифесте, вам также потребуется добавить соответствующее разрешение и объявление ресивера:

<receiver android:name=".NetworkChangeReceiver">
    <intent-filter>
        <action android:name="android.net.conn.CONNECTIVITY_CHANGE" />
    </intent-filter>
</receiver>

Важные соображения:

✅Начиная с Android 8.0 (API уровень 26), система налагает дополнительные ограничения на использование BroadcastReceiver для некоторых действий, чтобы оптимизировать производительность и энергопотребление. Например, некоторые системные широковещательные сообщения не могут быть получены через манифест для приложений, работающих в фоне.
✅Важно использовать BroadcastReceiver ответственно и не выполнять в onReceive длительные операции, так как это может привести к задержкам в работе приложения и увеличению потребления энергии.

BroadcastReceiver — это компонент, который позволяет вашему приложению реагировать на широковещательные сообщения от системы или других приложений, делая его мощным инструментом для обработки системных событий и межпроцессного взаимодействия.

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

🔐 База собесов | 🔐 База тестовых

Чем data class отличается от обычного класса ?
Спросят с вероятностью 27%

data class (класс данных) представляет собой специализированный тип класса, предназначенный для хранения данных. Основное отличие данного класса от обычного класса заключается в том, что Kotlin автоматически генерирует ряд полезных методов (например, equals(), hashCode(), toString(), copy()) для класса данных, что упрощает их использование для хранения данных без необходимости реализовывать эти методы вручную. Давайте рассмотрим основные отличия более подробно.

Автоматически сгенерированные методы

Когда вы объявляете data class, компилятор автоматически генерирует следующие методы на основе свойств, объявленных в первичном конструкторе класса:

✅equals() и hashCode(): Методы для сравнения объектов по значениям их свойств, а не по ссылкам в памяти.
✅toString(): Метод, возвращающий строковое представление объекта, включающее имя класса и значения всех его свойств.
✅copy(): Метод для создания копии объекта с возможностью изменения некоторых свойств в процессе копирования.

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

Ограничения и особенности

✅data class не может быть абстрактным, открытым (open), запечатанным (sealed) или внутренним (inner).
✅В data class должен быть хотя бы один параметр в первичном конструкторе и все эти параметры должны быть помечены как val или var.

В то время как data class предназначены для простого хранения данных, обычные классы используются для более широкого спектра задач, включая реализацию бизнес-логики и других функциональностей, которые не ограничиваются только хранением данных. В обычных классах разработчикам необходимо реализовывать методы equals(), hashCode(), toString() и другие вручную, если они нужны для корректной работы приложения.

Основное отличие data class от обычного класса заключается в автоматической генерации методов для работы с данными, что делает данный класс идеальным выбором для моделей данных. Обычные классы предназначены для более обширных задач и не предоставляют таких автоматических методов "из коробки".

Data class автоматически генерирует полезные методы для работы с данными, облегчая создание моделей данных, в то время как обычные классы используются для более обширных задач и требуют ручной реализации этих методов.

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

🔐 База собесов | 🔐 База тестовых

Как работает навигация по Activity ?
Спросят с вероятностью 13%

Навигация между различными Activity в Android-приложении представляет собой важный аспект управления потоком пользовательского интерфейса. Можно рассматривать как отдельный экран с пользовательским интерфейсом. Навигация между ними позволяет пользователям переходить от одного задания к другому. Рассмотрим, как осуществляется этот процесс.

Основные механизмы навигации

1️⃣Интенты (Intents):
✅Явные интенты (Explicit Intents): Используются, когда вы знаете конкретное Activity, которое хотите запустить. Они прямо указывают на класс Activity, который необходимо открыть.
✅Неявные интенты (Implicit Intents): Не указывают прямо на класс Activity. Вместо этого, они объявляют общую операцию, которую должно выполнить приложение, и позволяют системе определить наиболее подходящий компонент для её выполнения. Например, открытие веб-страницы или отправка данных между приложениями.

Пример явного интента для запуска:

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

В этом примере CurrentActivity — это активность, из которой происходит вызов, а NextActivity — активность, которую необходимо открыть.

Жизненный цикл и управление переходами:

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

Закрытие Activity:

Для возврата к предыдущему можно использовать:

finish();

Метод finish() закрывает текущее Activity, и вы возвращаетесь к предыдущему Activity в стеке активностей (back stack).

Использование флагов интента:

могут включать различные флаги для управления историей активностей и поведением переходов, например:

✅Intent.FLAG_ACTIVITY_CLEAR_TOP: Если активность уже запущена в текущем задании, то она поднимается на вершину стека, и все активности над ней уничтожаются.
✅Intent.FLAG_ACTIVITY_SINGLE_TOP: Если запущенная активность уже находится на вершине стека, новый экземпляр не будет создаваться.

Навигационные компоненты:

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

Навигация между Activity — это фундаментальный аспект создания приложений, который требует понимания жизненного цикла Activity, правильного использования интентов и потенциально использования современных инструментов управления навигацией для создания интуитивно понятного и удобного пользовательского интерфейса.

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

🔐 База собесов | 🔐 База тестовых

Привет, ребят, хочу сделать так, чтобы для каждого вопроса было поясняющее видео в reels/shorts формате.

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

Если интересует такая подработка напишите мне @kivaiko

Что такое сборщик мусора ?
Спросят с вероятностью 27%

Сборщик мусора (Garbage Collector, GC) — это механизм управления памятью, который автоматически освобождает память, выделенную для объектов, которые больше не используются в программе. Эта функция присутствует во многих современных языках программирования, где не требуется явно управлять памятью, как это делается в языках, например, C или C++.

Как он работает:

Работает в фоновом режиме, периодически сканируя память программы на предмет объектов, которые больше не доступны для использования. Доступность объекта обычно определяется по наличию "живых" ссылок на него. Если на объект нет активных ссылок, то считается, что он больше не нужен, и память, которую он занимает, может быть освобождена.

Существуют разные алгоритмы сборки мусора, но многие из них используют следующие базовые принципы:

1️⃣Пометка (Marking): Сканирует объекты, доступные из корневого набора (например, переменные на стеке, статические переменные), и помечает все объекты, которые можно достичь напрямую или косвенно, как "живые".

2️⃣Очистка (Sweeping): Затем сборщик проходит по всей куче (heap) памяти и освобождает память, занимаемую объектами, которые не были помечены как "живые".

Преимущества сборщика мусора:

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

Недостатки сборщика мусора:

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

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

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

🔐 База собесов | 🔐 База тестовых