Разработка Android-приложений с нуля. 3 издание.

Джон Хортон

Санкт-Петербург
«БХВ-Петербург»

2023

УДК 004.43
ББК 32.973-018.1

Х82

Хортон Дж.
Х82 Разработка Android-приложений с нуля. — 3-е изд.: Пер. с англ. — СПб.:

БХВ-Петербург, 2023. — 576 с.: ил. — (С нуля)

ISBN 978-5-9775-6855-5

Доступно изложены основы программирования на Java для Android, включая
объектно-ориентированное программирование. Описаны установка и настройка
среды разработки Android Studio, создание функциональных пользовательских ин-
терфейсов с помощью визуального редактора Android Studio. Раскрыты принципы
материального дизайна. Рассмотрены компоновки CardView и ScrollView, обра-
ботка касаний экрана, захват данных, использование в приложении звука и анима-
ции, поддержка различных версий Android и нескольких языков интерфейса. За-
тронута тема хранения данных во встроенной базе данных SQLite. Показаны
паттерны проектирования, используемые профессионалами для создания совре-
менных мобильных приложений.

Для начинающих программистов

УДК 004.43
ББК 32.973-018.1

Группа подготовки издания:

Руководитель проекта Павел Шалин
Зав. редакцией Людмила Гауль
Перевод с английского Игоря Донченко
Компьютерная верстка Ольги Сергиенко
Оформление обложки Зои Канторович

© Packt Publishing 2021. First published in the English language under the title ‘Android Programming
for Beginners – Third Edition – (9781800563438)’

Впервые опубликовано на английском языке под названием ‘Android Programming for Beginners – Third Edition –
(9781800563438)’

Подписано в печать 09.01.23.
Формат 70×1001/16. Печать офсетная. Усл. печ. л. 46,44.

Тираж 1000 экз. Заказ №
"БХВ-Петербург", 191036, Санкт-Петербург, Гончарная ул., 20.

Отпечатано с готового оригинал-макета
ООО "Принт-М", 142300, М.О., г. Чехов, ул. Полиграфистов, д. 1

ISBN 978-1-80056-343-8 (англ.) © Packt Publishing, 2021
ISBN 978-5-9775-6855-5 (рус.) © Перевод на русский язык, оформление.

ООО "БХВ-Петербург", ООО "БХВ", 2023

Оглавление

Предисловие .................................................................................................................................17
Для кого эта книга................................................................................................................................. 17
О чем эта книга ..................................................................................................................................... 18
Как получить максимум пользы от этой книги .................................................................................. 21
Файлы с примерами кода ..................................................................................................................... 22
Цветные изображения........................................................................................................................... 22
Условные обозначения ......................................................................................................................... 22
Контакты................................................................................................................................................ 23
Отзывы................................................................................................................................................... 23

Глава 1. Начало работы с Android и Java...............................................................................24
Технические требования....................................................................................................................... 25
Новое в третьем издании...................................................................................................................... 25
Почему Java и Android? ........................................................................................................................ 26
Первый камень преткновения для новичков ...................................................................................... 27
Как Java и Android работают вместе ................................................................................................... 27

Что такое Android API .................................................................................................................. 28
Java — объектно-ориентированный язык программирования.................................................. 29
Повторим: что такое Android....................................................................................................... 31
Android Studio ............................................................................................................................... 31
Настройка Android Studio..................................................................................................................... 32
Что делает приложение для Android?.................................................................................................. 35
Ресурсы Android............................................................................................................................ 35
Структура кода Java в Android ............................................................................................................. 36
Пакеты ........................................................................................................................................... 36
Классы ........................................................................................................................................... 37
Методы .......................................................................................................................................... 37
Создание нашего первого приложения для Android .......................................................................... 38
Развертывание приложения на данном этапе ..................................................................................... 42
Запуск и отладка приложения на эмуляторе Android ................................................................ 43
Запуск приложения на реальном устройстве.............................................................................. 45
Часто задаваемые вопросы................................................................................................................... 47
Итоги...................................................................................................................................................... 47

Глава 2. Первое знакомство: Java, XML и визуальный редактор.....................................48
Технические требования....................................................................................................................... 48
Изучение вывода Logcat ....................................................................................................................... 48

Фильтрация вывода Logcat .......................................................................................................... 49
Java-проект и XML-код основной компоновки .................................................................................. 50

Файл MainActivity.java ................................................................................................................. 50
Сворачивание (скрытие) кода в Android Studio................................................................ 50
Объявление пакета .............................................................................................................. 51
Импорт классов ................................................................................................................... 52
Класс..................................................................................................................................... 52
Методы внутри класса ........................................................................................................ 53
Итог по коду Java на данный момент ................................................................................ 53

6 Оглавление

Файл компоновки приложения .................................................................................................... 53
Элементы компоновки пользовательского интерфейса................................................... 56
Текстовые элементы пользовательского интерфейса ...................................................... 56
Элементы-кнопки пользовательского интерфейса........................................................... 57

Добавление кнопок в основной файл компоновки............................................................................. 57
Добавление кнопки с использованием визуального редактора ................................................ 58
Редактирование атрибутов кнопки .................................................................................... 60
XML-код новой кнопки ...................................................................................................... 62
Добавление кнопки путем редактирования XML-кода ............................................................. 63
Назначение кнопкам уникальных атрибутов id.......................................................................... 65
Размещение двух кнопок в компоновке...................................................................................... 65
Как заставить кнопки вызывать разные методы ........................................................................ 68

Комментирование Java-кода ................................................................................................................ 69
Отправка сообщений пользователю и разработчику ......................................................................... 69
Написание первого Java-кода............................................................................................................... 70

Добавление кода с сообщением в метод onCreate ..................................................................... 70
Изучение вывода ................................................................................................................. 71

Написание собственных методов Java ........................................................................................ 72
Изучение вывода ................................................................................................................. 74

Часто задаваемые вопросы................................................................................................................... 75
Итоги...................................................................................................................................................... 75

Глава 3. Android Studio и структура проекта ........................................................................77
Технические требования....................................................................................................................... 78
Проводник проекта и анатомия проекта ............................................................................................. 78
Структура файлов и папок в шаблоне проекта Empty Activity.......................................................... 78

Проект Empty Activity .................................................................................................................. 80
Папка manifests .................................................................................................................... 81
Папка java ............................................................................................................................ 83
Папка Java (generated) ........................................................................................................ 86
Папка res .............................................................................................................................. 86
Папка res/drawable .............................................................................................................. 86
Папка res/layout ................................................................................................................... 87
Папка res/mipmap ................................................................................................................ 87
Папка res/values ................................................................................................................... 89
Файл colors.xml.................................................................................................................... 89
Файл strings.xml ................................................................................................................... 90

Cтруктура файлов и папок в шаблоне проекта Basic Activity ........................................................... 92
Проект Basic Activity ............................................................................................................................ 93

Файл MainActivity.java ........................................................................................................ 93
Файл activity_main.xml ........................................................................................................ 96
Дополнительные методы в MainActivity.java .................................................................... 97
Эмулятор Android ................................................................................................................................. 98
Панель управления эмулятором .................................................................................................. 99
Использование эмулятора как реального устройства .............................................................. 100
Доступ к панели приложений........................................................................................... 100
Просмотр активных приложений и переключение между приложениями .................. 101
Итоги.................................................................................................................................................... 102

Глава 4. Начало работы с компоновками и материальный дизайн................................103
Технические требования..................................................................................................................... 104
Материальный дизайн ........................................................................................................................ 104

Оглавление 7

Дизайн пользовательского интерфейса Android............................................................................... 104
Компоновки ......................................................................................................................................... 105

Создание и изучение проекта компоновок ............................................................................... 105
Создание компоновки с помощью LinearLayout ...................................................................... 106
Добавление типа компоновки LinearLayout в проект .............................................................. 107
Подготовка рабочего пространства........................................................................................... 108
Изучение сгенерированного XML-кода.................................................................................... 108
Добавление TextView в пользовательский интерфейс ............................................................ 110
Добавление многострочного TextView в пользовательский интерфейс ................................ 112
Подключение пользовательского интерфейса с помощью кода Java. Часть 1 ...................... 113
Добавление компоновок в компоновки .................................................................................... 116
Украшение компоновки ............................................................................................................. 119
Подключение пользовательского интерфейса с помощью кода Java. Часть 2 ...................... 121
Создание точного пользовательского интерфейса с помощью ConstraintLayout .......................... 121
Добавление CalendarView .......................................................................................................... 121

Изменение размера представления в ConstraintLayout................................................... 122
Использование окна Component Tree .............................................................................. 122
Добавление ограничений вручную .................................................................................. 124
Добавление и ограничение дополнительных элементов пользовательского интерфейса........ 126
Создание интерактивного текста............................................................................................... 128
Размещение данных с помощью TableLayout ................................................................................... 129
Добавление элемента TableRow ................................................................................................ 130
Использование Component Tree для решения задач, невыполнимых
в визуальном редакторе .................................................................................................... 130
Организация столбцов таблицы................................................................................................. 132
Добавление ссылки на главное меню ................................................................................................ 134
Итоги.................................................................................................................................................... 135

Глава 5. Красивые компоновки на основе CardView и ScrollView ....................................136
Технические требования..................................................................................................................... 136
Атрибуты пользовательского интерфейса ........................................................................................ 136

Размеры и использование dp...................................................................................................... 136
Размеры шрифтов и использование sp...................................................................................... 137
Определение размера с wrap и match........................................................................................ 139
Использование padding и margin............................................................................................... 140
Использование свойства layout_weight ..................................................................................... 141
Использование gravity ................................................................................................................ 142
Создание пользовательского интерфейса с помощью CardView и ScrollView .............................. 144
Настройка представления с помощью кода Java...................................................................... 144
Добавление изображений........................................................................................................... 145
Создание контента для карточек ............................................................................................... 146
Определение размеров для CardView........................................................................................ 149
Добавление CardView в компоновку......................................................................................... 149

Добавление файлов компоновки внутрь другой компоновки ....................................... 151
Создание эмулятора планшета........................................................................................................... 154
Часто задаваемые вопросы................................................................................................................. 156
Итоги.................................................................................................................................................... 156

Глава 6. Жизненный цикл Android........................................................................................157
Технические требования..................................................................................................................... 157
Жизнь приложения для Android ........................................................................................................ 158
Взаимодействие Android с приложениями ....................................................................................... 158

8 Оглавление

Упрощенное объяснение жизненного цикла Android ...................................................................... 159
Демистификация фаз жизненного цикла .................................................................................. 160

Работа с фазами жизненного цикла ................................................................................................... 161
Демонстрационное приложение жизненного цикла ........................................................................ 163

Написание кода для демонстрационного приложения жизненного цикла ............................ 164
Запуск демонстрационного приложения жизненного цикла .................................................. 166
Вывод демонстрационного приложения жизненного цикла................................................... 167
Некоторые другие переопределенные методы......................................................................... 168
Еще раз о структуре кода Java ........................................................................................................... 170
Представление фрагментов и жизненного цикла ............................................................................. 171
Итоги.................................................................................................................................................... 172

Глава 7. Переменные, операторы и выражения Java.........................................................173
Технические требования..................................................................................................................... 173
Java повсюду........................................................................................................................................ 174
Синтаксис и жаргон Java .................................................................................................................... 174

Дополнительные комментарии к коду ...................................................................................... 175
Хранение и использование данных с переменными ........................................................................ 177

Типы переменных ....................................................................................................................... 178
Примитивные типы ........................................................................................................... 178
Ссылочные типы ............................................................................................................... 181

Использование переменных ............................................................................................................... 182
Объявление переменной..................................................................................................................... 182
Инициализация переменной............................................................................................................... 183
Изменение значений переменных с помощью операторов ............................................................. 184

Оператор присваивания ............................................................................................................. 184
Оператор сложения..................................................................................................................... 184
Оператор вычитания................................................................................................................... 185
Оператор деления ....................................................................................................................... 185
Оператор умножения.................................................................................................................. 185
Оператор инкремента ................................................................................................................. 186
Оператор декремента ................................................................................................................. 186
Выражения Java................................................................................................................................... 186
Демоприложение Expressing Yourself ....................................................................................... 187
Итог ...................................................................................................................................................... 189

Глава 8. Условия и циклы Java ..............................................................................................190
Технические требования..................................................................................................................... 190
Принятие решений в Java ................................................................................................................... 191

Отступы в коде для ясности....................................................................................................... 191
Больше операторов ..................................................................................................................... 192

Оператор сравнения .......................................................................................................... 192
Логический оператор отрицания ..................................................................................... 192
Оператор НЕравенства ..................................................................................................... 193
Оператор «больше»........................................................................................................... 193
Оператор «меньше» .......................................................................................................... 193
Оператор «больше или равно» ......................................................................................... 193
Оператор «меньше или равно»......................................................................................... 193
Логический оператор «И» ................................................................................................ 193
Логический оператор «ИЛИ»........................................................................................... 194
Оператор модуля ............................................................................................................... 194

Оглавление 9

Использование операторов для проверки переменных ........................................................... 194
Использование ключевого слова if языка Java................................................................ 194

Switch и принятие решений ................................................................................................................ 197
Демоприложение Switch ............................................................................................................ 198

Повторение кода с циклами ............................................................................................................... 200
Циклы while................................................................................................................................. 200
Выход из цикла.................................................................................................................. 202
Ключевое слово continue .................................................................................................. 203
Циклы do while............................................................................................................................ 204

Циклы for ............................................................................................................................................. 205
Демоприложение Loops для работы с циклами................................................................................ 206
Итоги.................................................................................................................................................... 209

Глава 9. Методы Java ...............................................................................................................210
Технические требования..................................................................................................................... 210
Еще раз о методах ............................................................................................................................... 210

Java-методы ................................................................................................................................. 211
Структура метода ................................................................................................................................ 211

Модификатор .............................................................................................................................. 212
Возвращаемый тип ..................................................................................................................... 213
Имя метода .................................................................................................................................. 214
Параметры ................................................................................................................................... 215
Тело метода ................................................................................................................................. 216
Демонстрационное приложение для изучения методов .................................................................. 216
Методы Real world...................................................................................................................... 217

Обнаружение области видимости переменной............................................................... 218
Перегрузка метода .............................................................................................................................. 219
Еще раз об области видимости и переменных ................................................................................. 221
Рекурсия метода .................................................................................................................................. 222
Вопросы ............................................................................................................................................... 224
Итоги.................................................................................................................................................... 225
Самостоятельное чтение .................................................................................................................... 226

Глава 10. Объектно-ориентированное программирование...............................................227
Технические требования..................................................................................................................... 227
Важное предупреждение об управлении памятью ........................................................................... 227
Объектно-ориентированное программирование .............................................................................. 228

Что такое ООП? .......................................................................................................................... 228
Инкапсуляция .................................................................................................................... 228
Полиморфизм .................................................................................................................... 229
Наследование..................................................................................................................... 229

Почему надо делать именно так? .............................................................................................. 230
Резюме: класс .............................................................................................................................. 230
Код класса............................................................................................................................................ 230
Реализация класса ....................................................................................................................... 231
Объявление, инициализация и использование объекта класса ............................................... 231
Приложение Basic Classes .................................................................................................................. 234
Что еще можно сделать с нашим первым классом .................................................................. 237
Часто задаваемые вопросы................................................................................................................. 238
Итоги.................................................................................................................................................... 238

10 Оглавление

Глава 11. Больше объектно-ориентированного программирования ..............................239
Технические требования..................................................................................................................... 239
Вы еще помните об инкапсуляции?................................................................................................... 239

Управление доступом к классам с помощью модификаторов доступа.................................. 240
Модификаторы доступа к классам................................................................................... 241
Резюме: доступ к классам ................................................................................................. 241

Управление доступом к переменным с помощью модификаторов доступа.......................... 241
Модификаторы доступа к переменным........................................................................... 242
Резюме: доступ к переменным ......................................................................................... 243

Методы и модификаторы доступа............................................................................................. 243
Модификаторы доступа к методам.................................................................................. 243
Резюме: доступ к методу .................................................................................................. 244

Доступ к private-переменным с помощью геттеров и сеттеров.......................................... 244
Настройка объектов с помощью конструкторов...................................................................... 247
Статические методы ........................................................................................................................... 249
Мини-приложение инкапсуляции и статических методов .............................................................. 251
ООП и наследование........................................................................................................................... 255
Приложение с наследованием............................................................................................................ 257
Полиморфизм ...................................................................................................................................... 261
Абстрактные классы ................................................................................................................... 262
Интерфейсы................................................................................................................................. 263
Часто задаваемые вопросы................................................................................................................. 265
Итоги.................................................................................................................................................... 265

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

Ссылки: повторное знакомство ................................................................................................. 267
Небольшой перерыв, чтобы выбросить мусор ............................................................... 267
Шесть фактов о стеке и куче ............................................................................................ 268

В чем польза этой кучи?............................................................................................................. 268
Использование кнопок и виджетов TextView из компоновки ................................................. 269
Запуск приложения ..................................................................................................................... 277
Внутренние и анонимные классы ...................................................................................................... 278
Часто задаваемые вопросы................................................................................................................. 279
Итоги.................................................................................................................................................... 279

Глава 13. Анонимные классы. Оживление виджетов Android .........................................280
Технические требования..................................................................................................................... 281
Объявление и инициализация объектов ............................................................................................ 281
Создание виджетов пользовательского интерфейса из Java без XML ........................................... 281
Изучение палитры. Часть 1 ................................................................................................................ 282

Виджет EditText........................................................................................................................... 283
Виджет ImageView ...................................................................................................................... 283
Радиокнопки и группы ............................................................................................................... 284
Анонимные классы ............................................................................................................................. 285
Изучение палитры и анонимные классы. Часть 2 ............................................................................ 288
Switch ........................................................................................................................................... 288
CheckBox...................................................................................................................................... 289
TextClock...................................................................................................................................... 290
Использование WebView ............................................................................................................ 290

Оглавление 11

Приложение Widget Exploration......................................................................................................... 291
Настройка проекта Widget Exploration и его пользовательского интерфейса ....................... 291
Написание кода для приложения Widget Exploration .............................................................. 297
Получение ссылок на все части пользовательского интерфейса .................................. 297
Написание кода с чекбоксами .......................................................................................... 299
Написание кода с радиокнопками.................................................................................... 301
Использование анонимного класса для обычной кнопки Button .................................. 302
Написание кода для виджета Switch ................................................................................ 303

Использование WebView..................................................................................................................... 304
Запуск приложения Widget Exploration............................................................................................. 304
Итоги.................................................................................................................................................... 306

Глава 14. Диалоговые окна Android ......................................................................................307
Технические требования..................................................................................................................... 307
Диалоговые окна ................................................................................................................................. 307

Создание проекта Dialog Demo ................................................................................................. 308
Написание кода класса DialogFragment ................................................................................... 308

Использование цепочки для конфигурации DialogFragment ........................................ 310
Использование класса DialogFragment..................................................................................... 311
Приложение Note to Self..................................................................................................................... 313
Применение соглашений об именах и строковых ресурсах.................................................... 314
Получение файлов кода для приложения Note to Self ............................................................. 314
Завершенное приложение .......................................................................................................... 315
Создание проекта........................................................................................................................ 318
Подготовка строковых ресурсов ............................................................................................... 318
Написание кода класса Note....................................................................................................... 319
Реализация компоновок для диалоговых окон ......................................................................... 321
Написание кода диалоговых окон ............................................................................................. 325

Написание кода класса DialogNewNote ........................................................................... 325
Написание кода класса DialogShowNote ......................................................................... 329
Удаление ненужных автосгенерированных фрагментов ............................................... 331
Демонстрация диалоговых окон................................................................................................ 332
Написание кода плавающей кнопки действия ................................................................ 333
Итоги.................................................................................................................................................... 336

Глава 15. Массивы, словари Map и случайные числа .......................................................337
Технические требования..................................................................................................................... 337
«Случайное» отступление .................................................................................................................. 338
Обработка больших объемов данных с помощью массивов ........................................................... 338

Массивы — это объекты ............................................................................................................ 340
Пример мини-приложения с простым массивом.............................................................................. 341
Реализация динамического массива .................................................................................................. 342

Мини-приложение с динамическим массивом......................................................................... 343
Работа с многомерными массивами .................................................................................................. 344

Мини-приложение с многомерным массивом.......................................................................... 344
Исключения Array-out-of-bounds............................................................................................... 347
Структура данных ArrayList ............................................................................................................... 348
Расширенный цикл for................................................................................................................ 349
Полиморфизм массивов и экземпляров ArrayList ............................................................................ 350
Больше коллекций Java: HashMap..................................................................................................... 351
Приложение Note to Self..................................................................................................................... 352

12 Оглавление

Часто задаваемые вопросы................................................................................................................. 353
Итоги.................................................................................................................................................... 353

Глава 16. Адаптеры и классы Recycler..................................................................................354
Технические требования..................................................................................................................... 354
RecyclerView и RecyclerAdapter.......................................................................................................... 354

Проблема с отображением большого количества виджетов................................................... 355
Решение проблемы отображения большого количества виджетов ........................................ 355
Практическое применение RecyclerView и RecyclerAdapter.................................................... 356
Настройка RecyclerView с RecyclerAdapter и заметками ArrayList ......................................... 357
Добавление RecyclerView, RecyclerAdapter и ArrayList в проект Note to Self ................................ 358
Удаление временной кнопки Show Note и добавление RecyclerView.............................................. 358
Создание элемента списка для RecyclerView ........................................................................... 359
Написание кода класса RecyclerAdapter.................................................................................... 360

Написание кода конструктора NoteAdapter .................................................................... 364
Написание кода метода onCreateViewHolder.................................................................. 364
Написание метода onBindViewHolder.............................................................................. 365
Написание кода метода getItemCount .............................................................................. 365
Написание кода внутреннего класса ListItemHolder....................................................... 366
Написание кода MainActivity для использования классов RecyclerView и RecyclerAdapter.. 367
Добавление кода в метод onCreate .................................................................................. 367
Изменение метода addNote............................................................................................... 368
Написание метода showNote............................................................................................. 368
Запуск приложения ............................................................................................................................. 369
Часто задаваемые вопросы................................................................................................................. 370
Итоги.................................................................................................................................................... 370

Глава 17. Сохранение и совместное использование данных.............................................371
Технические требования..................................................................................................................... 371
«Намерения» Android ......................................................................................................................... 372

Переключение Activity ................................................................................................................ 372
Передача данных между активностями .................................................................................... 373
Добавление страницы настроек в Note to Self .................................................................................. 374
Создание SettingsActivity ............................................................................................................ 374
Разработка компоновки экрана настроек.................................................................................. 375
Предоставление пользователю возможности переключаться на экран настроек ................. 375
Сохранение данных с помощью SharedPreferences ......................................................................... 377
Загрузка данных с помощью SharedPreferences............................................................................... 378
Сохранение настроек приложения Note to Self ................................................................................ 379
Написание кода класса SettingsActivity...................................................................................... 379
Написание кода класса MainActivity.......................................................................................... 381
Более продвинутый способ сохранения данных............................................................................... 383
Классы JSON ............................................................................................................................... 383
Исключения Java: try, catch и finally ......................................................................................... 384
Резервное копирование пользовательских данных в Note to Self ................................................... 385
Часто задаваемые вопросы................................................................................................................. 391
Итоги.................................................................................................................................................... 391

Глава 18. Локализация .............................................................................................................392
Технические требования..................................................................................................................... 392
Реализация поддержки испанского и немецкого языков в приложении Note to Self .................... 392

Добавление поддержки испанского языка................................................................................ 393

Оглавление 13

Добавление поддержки немецкого языка ................................................................................. 393
Добавление строковых ресурсов ............................................................................................... 394
Запуск приложения Note to Self на немецком или испанском языке.............................................. 396
Выполнение переводов в коде Java ........................................................................................... 396
Итоги.................................................................................................................................................... 399

Глава 19. Анимация и интерполяторы .................................................................................400
Технические требования..................................................................................................................... 400
Анимации в Android ........................................................................................................................... 400

Создание интересной анимации в XML.................................................................................... 401
Исчезновение и появление ............................................................................................... 401
Движение ........................................................................................................................... 401
Масштабирование, или растяжение................................................................................. 401
Контроль продолжительности ......................................................................................... 402
Вращение ........................................................................................................................... 402
Повторение анимации....................................................................................................... 402
Комбинирование эффектов анимации с помощью set ................................................... 402

Создание анимаций и управление ими с помощью кода Java................................................. 403
Дополнительные функции анимации ........................................................................................ 403

Слушатели анимации ........................................................................................................ 403
Интерполяторы анимации ................................................................................................ 404
Демонстрационное приложение анимации. Знакомство с SeekBar ................................................ 405
Демонстрационная анимация .................................................................................................... 405
Написание кода XML-анимации................................................................................................ 408
Использование Java в демонстрационном приложении анимации......................................... 412
Часто задаваемые вопросы................................................................................................................. 420
Итоги.................................................................................................................................................... 421

Глава 20. Рисование и графика ..............................................................................................422
Технические требования..................................................................................................................... 422
Понятие о классе Canvas .................................................................................................................... 422

Рисование с помощью Bitmap, Canvas и ImageView................................................................ 423
Canvas и Bitmap ................................................................................................................. 423
Paint.................................................................................................................................... 423
ImageView и Activity .......................................................................................................... 424
Краткий обзор Canvas, Bitmap, Paint и ImageView......................................................... 424

Использование класса Canvas............................................................................................................ 425
Подготовка экземпляров необходимых классов ...................................................................... 425
Инициализация объектов ........................................................................................................... 425
Настройка содержимого Activity................................................................................................ 426

Демонстрационное приложение Canvas ........................................................................................... 426
Создание нового проекта ........................................................................................................... 426
Написание кода демонстрационного приложения Canvas............................................. 427
Инициализация Bitmap...................................................................................................... 428
Рисование на экране.......................................................................................................... 428
Метод Color.argb............................................................................................................... 429

Система координат Android ............................................................................................................... 431
Черчение и рисование ................................................................................................................ 431

Создание растровых изображений .................................................................................................... 432
Управление растровыми изображениями ......................................................................................... 433

Что такое растровое изображение............................................................................................. 433

14 Оглавление

Класс Matrix ................................................................................................................................ 433
Поворот растрового изображения в противоположное направление........................... 434
Поворот растрового изображения вверх или вниз ......................................................... 435

Демонстрационное приложение для работы с растровыми изображениями................................. 436
Добавление графики в проект.................................................................................................... 436

Часто задаваемые вопросы................................................................................................................. 440
Итоги.................................................................................................................................................... 440

Глава 21. Потоки. Разработка приложения для интерактивного рисования................441
Технические требования..................................................................................................................... 441
Создание проекта Live Drawing ......................................................................................................... 441

Рефакторинг MainActivity в LiveDrawingActivity ...................................................................... 442
Блокировка игры в полноэкранном альбомном режиме ......................................................... 442

Создание классов для нового приложения...................................................................... 443
О структуре приложения Live Drawing..................................................................................... 443
Написание кода класса LiveDrawingActivity ............................................................................. 444
Написание кода класса LiveDrawingView ................................................................................. 447

Добавление полей класса.................................................................................................. 449
Написание кода конструктора LiveDrawingView ............................................................ 451
Написание кода метода draw............................................................................................ 453
Добавление метода printDebuggingText .......................................................................... 454
Метод draw и класс SurfaceView ...................................................................................... 455
Игровой цикл....................................................................................................................................... 456
Потоки.................................................................................................................................................. 458
Возможные проблемы с потоками ............................................................................................ 459
Реализация игрового цикла с помощью потока................................................................................ 462
Реализация Runnable и подготовка метода run......................................................................... 462
Написание кода потока............................................................................................................... 463
Запуск и остановка потока ......................................................................................................... 463
Использование жизненного цикла Activity для запуска и остановки потока ......................... 464
Написание кода метода run........................................................................................................ 464
Запуск приложения ............................................................................................................................. 467
Итоги.................................................................................................................................................... 468

Глава 22. Системы частиц и обработка касаний экрана...................................................469
Технические требования..................................................................................................................... 469
Добавление пользовательских кнопок на экран ............................................................................... 470
Реализация эффекта системы частиц ................................................................................................ 470

Написание кода класса Particle ................................................................................................. 471
Написание кода класса ParticleSystem ...................................................................................... 473
Создание систем частиц в классе LiveDrawingView ................................................................ 478
Обработка касаний.............................................................................................................................. 479
Написание кода метода onTouchEvent ...................................................................................... 481
Завершение создания HUD ........................................................................................................ 482
Запуск приложения ............................................................................................................................. 483
Profiler: инструмент профилирования Android Studio..................................................................... 484
Итоги.................................................................................................................................................... 487

Глава 23. Поддержка различных версий Android, звуковые эффекты
и виджет Spinner.........................................................................................................................488
Работа с разными версиями Android ................................................................................................. 488

Определение текущей версии Android...................................................................................... 489

Оглавление 15

Класс SoundPool.................................................................................................................................. 489
Инициализация SoundPool новым способом............................................................................ 490
Инициализация SoundPool старым способом........................................................................... 491
Загрузка звуковых файлов в память................................................................................. 491
Воспроизведение звука ..................................................................................................... 492
Остановка звука................................................................................................................. 493

Звуковое демонстрационное приложение и знакомство с виджетом Spinner................................ 493
Создание звуковых эффектов .................................................................................................... 493
Настройка звука .......................................................................................................................... 496
Написание кода звукового демоприложения............................................................................ 498

Итоги.................................................................................................................................................... 502

Глава 24. Шаблоны проектирования, множество компоновок и фрагменты...............503
Технические требования..................................................................................................................... 503
Паттерн model-view-controller............................................................................................................ 504
Рекомендации по дизайну приложений для Android ....................................................................... 505
Реальные приложения......................................................................................................................... 506
Мини-приложение для обнаружения устройств............................................................................... 508

Написание кода класса MainActivity.......................................................................................... 511
Разблокировка автоповорота экрана ............................................................................... 512

Запуск приложения ..................................................................................................................... 513
Квалификаторы конфигурации .......................................................................................................... 514

Ограничение квалификаторов конфигурации .......................................................................... 516
Фрагменты ........................................................................................................................................... 517

Фрагменты: жизненный цикл .................................................................................................... 517
Управление фрагментами с помощью FragmentManager ....................................................... 517
Наше первое приложение с Fragment ............................................................................................... 519
Проверка фрагмента в реальных условиях ....................................................................................... 524
Часто задаваемые вопросы................................................................................................................. 525
Итоги.................................................................................................................................................... 525

Глава 25. Создание приложения простой галереи изображений......................................526
Технические требования..................................................................................................................... 526
Классическое свайп-меню Angry Birds ............................................................................................. 526
Создание галереи изображений (слайдера)....................................................................................... 527

Реализация компоновки ............................................................................................................. 528
Написание кода класса PagerAdapter........................................................................................ 529
Написание кода класса MainActivity.......................................................................................... 531
Запуск приложения галереи ....................................................................................................... 533
Итог ...................................................................................................................................................... 533

Глава 26. Расширенный пользовательский интерфейс с Navigation Drawer
и Fragment ...................................................................................................................................534
Технические требования..................................................................................................................... 534
Знакомство с NavigationView ............................................................................................................. 535
Простое приложение базы данных .................................................................................................... 536

Insert............................................................................................................................................. 536
Delete............................................................................................................................................ 536
Search........................................................................................................................................... 537
Results .......................................................................................................................................... 538
Реализация проекта Age Database...................................................................................................... 538

16 Оглавление

Изучение автоматически сгенерированного кода и ресурсов ......................................................... 538
Написание кода классов Fragment и их компоновок ............................................................... 540
Создание пустых файлов для классов и компоновок............................................................... 540
Написание классов...................................................................................................................... 540
Разработка компоновок .............................................................................................................. 543
Разработка content_insert.xml..................................................................................................... 543
Разработка content_delete.xml .................................................................................................... 543
Разработка content_search.xml ................................................................................................... 544
Разработка content_results.xml ................................................................................................... 545

Использование классов Fragment и их компоновок......................................................................... 545
Редактирование меню Navigation Drawer................................................................................. 545
Добавление держателя к основной компоновке....................................................................... 546
Написание кода класса MainActivity.java.................................................................................. 547

Итоги.................................................................................................................................................... 550

Глава 27. Базы данных Android..............................................................................................551
Технические требования..................................................................................................................... 551
Базы данных ........................................................................................................................................ 552

Что такое база данных? .............................................................................................................. 552
Что такое SQL? ........................................................................................................................... 552
Что такое SQLite? ....................................................................................................................... 552
Учебник по синтаксису SQL .............................................................................................................. 553
Пример кода SQLite.................................................................................................................... 553

Создание таблицы ............................................................................................................. 553
Добавление данных в базу ................................................................................................ 554
Получение данных из базы ............................................................................................... 554
Обновление структуры базы данных ............................................................................... 555
Android SQLite API ............................................................................................................................. 555
SQLiteOpenHelper и SQLiteDatabase ......................................................................................... 555
Создание и выполнение запросов.............................................................................................. 555
Курсоры базы данных................................................................................................................. 557
Написание кода класса базы данных ................................................................................................. 558
Написание кода классов Fragment для использования класса DataManager................................. 562
Запуск приложения Age Database ...................................................................................................... 565
Итоги.................................................................................................................................................... 567

Глава 28. Краткое напутствие перед расставанием ...........................................................568
Публикация приложения .................................................................................................................... 568
Создайте приложение!........................................................................................................................ 569
Продолжайте учиться ......................................................................................................................... 569

Продолжайте читать................................................................................................................... 569
GitHub .......................................................................................................................................... 570
Stack Overflow ............................................................................................................................. 570
Форумы пользователей Android ................................................................................................ 572
Обучение более высокого уровня.............................................................................................. 572
Каналы связи с автором...................................................................................................................... 572
До свидания и спасибо! ...................................................................................................................... 573

Предметный указатель ..................................................................................................................574

Предисловие

Вы хотите связать свою карьеру с программированием, но не знаете, с чего начать?
У вас есть отличная идея для приложения, но нет представления о том, как ее реа-
лизовать? Если так, то эта книга для вас!
Книга Разработка Android-приложений с нуля (Android Programming for Beginners)
в обновленной третьей редакции1 станет вашим незаменимым помощником в соз-
дании приложений Android. Вы познакомитесь с большинством фундаментальных
концепций программирования в контексте Android, от основ Java до работы
с Android API. Все примеры, используемые в книге, основаны на современных
классах API и создаются в Android Studio — официальной среде разработки
Android, которая помогает ускорить процесс разработки приложений.
После краткого теоретического курса мы углубимся в программирование для
Android, и вы узнаете, как создавать приложения с профессиональным стандартным
пользовательским интерфейсом с помощью фрагментов и сохранять пользователь-
ские данные с помощью SQLite. Кроме того, вы узнаете, как сделать приложение
многоязычным, как реализовать функцию рисования на экране пальцем, а также
научитесь работать с графикой, звуком и анимацией.
Изучив эту книгу до конца, вы будете готовы к созданию собственных приложений
на Android и Java.

Для кого эта книга

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

1 В России издается впервые. — Ред.

18 Предисловие

О чем эта книга

Глава 1. Начало работы с Android и Java: об особенностях и замечательных свой-
ствах Android, о том, что представляют собой Android и Java, как они работают и
дополняют друг друга и какое это имеет значение для нас — будущих разработчи-
ков. Данная глава позволит существенно сократить подготовительный этап разра-
ботки приложений для Android. Быстро продвигаясь вперед, мы настроим необхо-
димое программное обеспечение для создания и развертывания простого первого
приложения.

Глава 2. Первое знакомство: Java, XML и визуальный редактор: о том, как на дан-
ном этапе получить рабочую среду разработки Android, а также создать и развер-
нуть свое первое приложение. Затем, чтобы начать понимать Android и научиться
использовать этот полезный шаблон, нам нужно изучить автоматически сгенериро-
ванный код.

Глава 3. Android Studio и структура проекта: о том, как создать и запустить еще
два проекта Android. Целью этих упражнений является более глубокое изучение
Android Studio и структуры проектов Android. Наряду с пониманием структуры
проектов мы поймем, как получать максимальную отдачу от эмулятора.

Глава 4. Начало работы с компоновками и материальный дизайн: о том, как соз-
дать еще три компоновки — они всё еще довольно просты, но являются шагом впе-
ред по сравнению с тем, что мы делали до сих пор. Прежде чем приступить к прак-
тической части, кратко познакомимся с концепцией материального дизайна. Также
мы рассмотрим различные типы компоновок — LinearLayout, ConstraintLayout и
TableLayout, и напишем код Java для переключения между разными компоновками
в одном приложении (проекте). Это первое зничительное приложение, которое
объединяет несколько тем в одну аккуратную «упаковку».

Глава 5. Красивые компоновки на основе CardView и ScrollView: последняя глава
о компоновках, прежде чем на какое-то время сосредоточиться на Java и объектно-
ориентированном программировании. Мы формализуем наше обучение на некото-
рых уже знакомых нам атрибутах, а также представим еще две отличные компо-
новки на основе ScrollView и CardView. В заключение главы мы запустим проект
CardView на эмуляторе планшета.

Глава 6. Жизненный цикл Android: о жизненном цикле приложения для Android.
Жизненный цикл Android — это способ взаимодействия всех приложений Android
с операционной системой (ОС) Android. Мы узнаем, каковы фазы жизненного
цикла, через которые проходит приложение от создания до уничтожения, и каким
образом это помогает понять, где разместить свой Java-код, в зависимости от
имеющихся целей и задач.

Глава 7. Переменные, операторы и выражения Java: об основах Java — код, нахо-
дящийся в создаваемых классах и методах, а также данные, с которыми он взаимо-
действует. В этой главе мы сосредоточимся на данных и будем учиться писать соб-
ственный код Java. К концу главы вы научитесь писать код Java, который создает и
использует данные в Android.

Предисловие 19

Глава 8. Условия и циклы Java: о том, как можно действовать в зависимости от зна-
чения переменной. Мы рассмотрим принятие решений на Java с помощью if, else и
switch, а также циклы в Java с командами while, do-while, for и break.

Глава 9. Методы Java: о методах, которые рассматриваются здесь более подробно.
Да, вы можете обращаться к ним, чтобы они выполняли свой код, но есть вещи, ко-
торые мы не обсуждали до этого момента.

Глава 10. Объектно-ориентированное программирование: о фундаментальном зна-
чении классов в Java практически для всего. Мы начнем понимать, почему инжене-
ры по программному обеспечению в Sun Microsystems еще в начале 1990-х годов
сделали Java именно таким, каков он есть. В предыдущих главах мы говорили
о переиспользовании чужого кода, в частности Android API, но сейчас подробно
разберем, как это работает, узнаем об объектно-ориентированном программирова-
нии и о том, как его использовать.

Глава 11. Больше объектно-ориентированного программирования: вторая часть
нашего головокружительного путешествия (теоретического и практического)
в ООП. Мы уже обсудили кратко концепции инкапсуляции, наследования и поли-
морфизма, но в этой главе мы увидим их в действии в демонстрационных прило-
жениях. Хотя в рабочих примерах эти концепции будут показаны в их простейших
формах, они тем не менее будут значительным шагом на пути к получению контро-
ля над XML-компоновками с помощью кода Java.

Глава 12. Стек, куча и сборщик мусора: недостающее звено между Java и XML-
компоновками, которое позволит добавлять все виды виджетов в приложения. По-
добное мы делали и раньше, но на этот раз сможем управлять виджетами с помо-
щью нашего Java-кода. Мы возьмем под свой контроль некоторые довольно про-
стые элементы пользовательского интерфейса, такие как Button и TextView. Чтобы
понять суть происходящего, нам нужно узнать немного больше о памяти устройст-
ва Android и двух ее областях — стеке и куче.

Глава 13. Анонимные классы. Оживление виджетов Android: экспериментирование
с виджетами. Теперь, когда у нас есть понимание компоновки и создания приложе-
ний Android, а также объектно-ориентированного программирования и способов
управления пользовательским интерфейсом из кода Java, мы готовы эксперименти-
ровать с другими виджетами из палитры наряду с анонимными классами. В этой
главе мы многое изменим, вернувшись к палитре Android Studio и просмотрев пол-
дюжины виджетов, которые мы либо не видели совсем, либо еще не использовали
в полной мере. Как только мы это сделаем, мы поместим их все в компоновку и по-
тренируемся манипулировать ими с помощью кода Java.

Глава 14. Диалоговые окна Android: о том, как продемонстрировать пользователю
всплывающее диалоговое окно. Мы сможем теперь использовать все наши знания
для реализации первой фазы своего первого крупного приложения — Note to self.
Затем в этой главе и четырех последующих (до главы 18) мы узнаем о новых функ-
циях Android и Java и используем недавно приобретенные знания для последова-
тельного улучшения приложения Note to self. В каждой главе мы также будем соз-
давать набор небольших приложений, независимых от этого основного приложе-
ния.

20 Предисловие

Глава 15. Массивы, словари Map и случайные числа: о массивах Java, которые по-
зволяют нам организованно и эффективно управлять потенциально огромным
объемом данных. Мы будем использовать близкую к массиву структуру ArrayList,
и увидим различия между ними. Когда мы научимся обрабатывать значительные
объемы данных, то увидим, что́ имеется в Android API для связывания наших
знаний по обработке данных с практической работой с пользовательским интер-
фейсом.

Глава 16. Адаптеры и классы Recycler: теория адаптеров и списков. Мы узнаем, как
расширить RecyclerAdapter в коде Java и добавить RecyclerView, который позво-
ляет отображать список для пользовательского интерфейса, а затем, с помощью
очевидной магии Android API, свяжем их вместе, чтобы RecyclerView отображал
содержимое RecyclerAdapter и позволял пользователю прокручивать содержимое.

Глава 17. Сохранение и совместное использование данных: о различных способах
сохранения данных в постоянном хранилище Android-устройства. Кроме того, мы
впервые добавим в наше приложение вторую активность. Это часто имеет смысл
при реализации отдельного «экрана» в приложении (например, экрана настроек).
Мы увидим, как добавить такую активность, чтобы пользователь мог переключать-
ся между ними.

Глава 18. Локализация: о том, как добавлять дополнительные языки в приложение.
Мы увидим, насколько важно и полезно правильное добавление текста с помощью
ресурсов String, когда требуется реализовать поддержку нескольких языков.

Глава 19. Анимация и интерполяторы: о том, как использовать класс Animation,
чтобы сделать наш пользовательский интерфейс менее статичным и более интерес-
ным. Как и предполагалось, Android API позволит нам создавать некоторые до-
вольно сложные вещи при помощи сравнительно простого кода, и класс Animation
здесь не исключение.

Глава 20. Рисование и графика: о классе Android Canvas и связанных с ним клас-
сах, таких как Paint, Color и Bitmap. Сочетание этих классов оказывается необы-
чайно мощным, когда дело доходит до рисования на экране. Если мы хотим создать
приложение для рисования, выводить графики или, возможно, написать свою игру,
нам нужно взять под контроль каждый пиксел, имеющийся у устройства Android.

Глава 21. Потоки. Разработка приложения для интерактивного рисования: о том,
как разработать приложение для рисования в детском стиле, в котором пользова-
тель может рисовать пальцем на экране. Приложение имеет свою особенность —
линии, нарисованные пользователем, будут состоять из элементов, которые могут
разлетаться на тысячи частиц. Проект будет называться Live Drawing.

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

Предисловие 21

Глава 23. Поддержка различных версий Android, звуковые эффекты и виджет
Spinner: о том, как определять и обрабатывать разные версии Android. После этого
можно приступить к изучению класса SoundPool и понять, как его использовать
в зависимости от версии Android, на которой работает приложение. На данном эта-
пе мы используем все, что знаем, для создания отличного звукового демонстраци-
онного приложения, которое познакомит нас с новым виджетом пользовательского
интерфейса — Spinner.

Глава 24. Шаблоны проектирования, множество компоновок и фрагменты: боль-
ше полезного, чем все, что было в книге до сих пор, для ваших будущих приложе-
ний. Мы рассмотрим некоторые аспекты Java и Android, которые вы можете ис-
пользовать в качестве фреймворка или шаблона для создания еще более интерес-
ных и сложных приложений, сохраняя при этом управляемость кода. Кроме того,
я предлагаю здесь темы для дальнейшего изучения, которым в этой книге просто не
хватит места.

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

Глава 26. Расширенный пользовательский интерфейс с Navigation Drawer и Frag-
ment: о самом (возможно) продвинутом пользовательском интерфейсе. Знакомство
с виджетом NavigationView, который можно создать путем выбора его в качестве
шаблона при реализации нового проекта. Мы изучим автоматически сгенерирован-
ный код и узнаем, как с ним взаимодействовать. Далее используем все свои знания
о Fragment, чтобы наполнить каждый «блок» различным поведением и представ-
лениями.

Глава 27. Базы данных Android: о том, как управлять, хранить и фильтровать значи-
тельные объемы данных (это обязательно потребуется, если мы собираемся созда-
вать приложения с важными для пользователей функциями). Классы JSON и
SharedPreferences справляются со своими задачами, но в какой-то момент нам
нужно перейти к использованию реальных баз данных для реальных решений.
Android использует систему управления базами данных SQLite, и, как вы можете
предположить, существует API, который максимально упрощает эту задачу.

Глава 28. Краткое напутствие перед расставанием: завершение нашего путешест-
вия. В этой главе вы найдете несколько идей и советов, с которыми, возможно, за-
хотите ознакомиться, прежде чем броситесь создавать собственные приложения.

Как получить максимум пользы от этой книги

Чтобы успешно заниматься, руководствуясь этой книгой, вам не требуется никако-
го опыта. Если вы уверенно работаете в своей операционной системе (Windows,
macOS или Linux), вы можете научиться создавать приложения для Android, одно-
временно изучая язык программирования Java. Разработка приложений профессио-

22 Предисловие

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

Файлы с примерами кода

Вы можете скачать файлы с примерами кода для этой книги с GitHub по адресу:
https://github.com/PacktPublishing/Android-Programming-for-BeginnersThird-
Edition.
В случае обновления кода он будет доступен в существующем репозитории GitHub.
Есть также другие пакеты кода из нашего обширного каталога книг и видео, дос-
тупные по адресу: https://github.com/PacktPublishing/. Изучите их!

Цветные изображения

К книге прилагается файл PDF с цветными изображениями (скриншоты, диаграм-
мы и пр). Вы можете скачать его здесь:
https://static.packt-cdn.com/downloads/9781800563438_ColorImages.pdf.

Условные обозначения

В этой книге используется ряд условных обозначений.
Код в тексте: обозначает слова программного кода в тексте, имена таблиц базы
данных, имена папок, имена и расширения файлов, пути, фиктивные URL-адреса,
ввод данных пользователем и имена Twitter.
Например: «Последнее поле класса — это экземпляр LayoutInflater, который будет
использоваться для наполнения каждого из экземпляров pager_item.xml».
Блок кода устанавливается следующим образом:

@Override
public int getCount() {

return images.length;
}

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

Предисловие 23

import androidx.appcompat.app.AppCompatActivity;
import androidx.viewpager.widget.PagerAdapter;
import androidx.viewpager.widget.ViewPager;

Любой ввод или вывод командной строки записывается следующим образом:

$ mkdir css
$ cd css

Жирным шрифтом выделены важные термины, элементы интерфейса, пункты ме-
ню, слово или слова, которые вы видите на экране. Например, таким образом в тек-
сте отображаются слова из меню или диалоговых окон: «Выберите Информацию
о системе на панели Администрирование».

СОВЕТЫ или ПРИМЕЧАНИЯ
Выглядят вот так.

Контакты

Отзывы наших читателей всегда приветствуются.
Общие отзывы: Если у вас есть вопросы по какому-либо аспекту этой книги, ука-
жите название книги в теме вашего сообщения и напишите нам по адресу:
[email protected].
Об ошибках: Хотя мы приложили все усилия, чтобы обеспечить точность нашего
контента, ошибки все же случаются. Если вы обнаружили в книге ошибку, мы бу-
дем благодарны, если вы сообщите нам об этом. Зайдите на www.packtpub.com/
support/errata, выберите свою книгу, затем ссылку Errata Submission Form и из-
ложите свои замечания.
О пиратстве: Если вы обнаружите какие-либо незаконные копии наших работ
в любой форме в Интернете, мы будем благодарны, если вы предоставите нам ин-
формацию об их местонахождении или сообщите название веб-сайта. Пожалуйста,
свяжитесь с нами по адресу: [email protected], и дайте ссылку на материал.
Если вы хотите стать автором: Если вы хорошо разбираетесь в какой-либо теме
и заинтересованы в написании книги или участии в работе над ней, посетите
authors.packtpub.com.

Отзывы

Пожалуйста, оставьте отзыв! После того как вы прочитали и воспользовались этой
книгой, почему бы не оставить отзыв о ней (например, на сайте, где вы ее купили)?
Тогда потенциальные читатели смогут увидеть и учесть ваше объективное мнение,
прежде чем принять решение о покупке, а издатели и авторы — понять, что́ вы
думаете о книге, и ознакомиться с вашими отзывами о ней. Спасибо!

1

Начало работы
с Android и Java

Добро пожаловать в третье издание книги Разработка Android-приложений для
начинающих! В первой главе мы не будем заниматься программированием для
Android, а рассмотрим отличительные особенности и замечательные свойства
Android, узнаем, что представляют собой Android и Java, как они работают и до-
полняют друг друга и что это значит для нас — будущих разработчиков. Быстро
продвигаясь вперед, мы научимся настраивать необходимое программное обеспе-
чение для создания и развертывания простого первого приложения.

ПРИМЕЧАНИЕ
Моя цель — постоянно обновлять эту книгу. Пожалуйста, посетите следующую веб-
страницу, где вы можете обсудить любые изменения, которые появились в Android
Studio после выхода в свет первого издания, а также найти полезные советы:
http://gamecodeschool.com/books/android-programming-for-beginners-
3rdedition#android-studio-updates.

Изучив эту главу, мы узнаем:
что нового в третьем издании;
как Java и Android работают вместе;
как настроить нашу среду разработки — Android Studio, содержащую все ком-
поненты, которые участвуют в создании приложений для Android и которые мы
рассмотрим позже;
что такое Java Development Kit (JDK) и интерфейс программирования приложе-
ний Android (Application Programming Interface, API) и как мы используем их
в Android Studio;
как создать свое самое первое приложение для Android;
как развернуть приложение на эмуляторе Android;
как запустить приложение на эмуляторе Android и на реальном устройстве.

И это еще не всё, так что приступим!

Начало работы с Android и Java 25

Технические требования

Ниже приведены официальные технические требования для Android-разработки
с помощью Android Studio и ее инструментов. Однако следует иметь в виду, что это
абсолютный минимум. Дополнительные сведения см. в разд. «Настройка Android
Studio» данной главы.

Требования для Windows:
Microsoft® Windows® 7/8/10 (64-разрядная);
4 Гбайт оперативной памяти минимум; рекомендуется 8 Гбайт ОЗУ;
2 Гбайт доступного дискового пространства минимум; рекомендуется 4 Гбайт
(500 Мбайт для интегрированной среды разработки (Integrated Development
Environment, IDE) + 1,5 Гбайт для пакета разработки программного обеспечения
Android (Software Development Kit, SDK) и образа эмулятора);
минимальное разрешение экрана 1280×800.

Требования для Mac:
Mac® OS X® 10.10 (Yosemite) или выше, до 10.14 (macOS Mojave);
4 Гбайт оперативной памяти минимум; рекомендуется 8 Гбайт ОЗУ;
2 Гбайт доступного дискового пространства минимум; рекомендуется 4 Гбайт
(500 Мбайт для IDE + 1,5 Гбайт для Android SDK и образа эмулятора);
минимальное разрешение экрана 1280 × 800.

Требования для Linux:
рабочий стол GNOME или KDE;
64-битный дистрибутив с возможностью запуска 32-битных приложений;
библиотека GNU C (glibc) 2.19 или новее;
4 Гбайт оперативной памяти минимум; рекомендуется 8 Гбайт ОЗУ;
2 Гбайт доступного дискового пространства минимум; рекомендуется 4 Гбайт
(500 Мбайт для IDE + 1,5 Гбайт для Android SDK и образа эмулятора);
минимальное разрешение экрана 1280 × 800.

Файлы c кодом для этой главы вы можете найти на GitHub по адресу:
https://github.com/PacktPublishing/Android-Programming-for-Beginners-
ThirdEdition/tree/main/chapter%2001.

Новое в третьем издании

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

26 Глава 1

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

Почему Java и Android?

Когда Android впервые появился в 2008 году, он был немного унылым по сравне-
нию с гораздо более стильной iOS на Apple iPhone/iPad. Но довольно быстро благо-
даря разнообразным моделям мобильных телефонов, которые стали востребован-
ными как среди практичных и экономных, так и среди модных и технически подко-
ванных людей, количество пользователей Android резко возросло.

Для многих, в том числе и для меня, разработка для Android — это и самое полез-
ное развлечение, и бизнес.

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

Довольно сложно сказать, почему это так. Возможно, дело в том, что платформа
бесплатная и с открытым исходным кодом. Вы можете распространять свои при-
ложения без разрешения крупной контролирующей корпорации, и никто не сможет
вас остановить. В то же время к вашим услугам есть устоявшиеся, контролируемые
корпорацией массовые рынки, такие как Amazon Appstore и Google Play.

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

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

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

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

Начало работы с Android и Java 27

увеличением мощности процессоров и непрерывным развитием самой операцион-
ной системы Android потребность в профессиональных разработчиках приложений
будет только расти.

Одним словом, лучшие разработчики Android — и, что более важно, разработчики
Android с лучшими идеями и решимостью — пользуются бо́льшим спросом, чем
когда-либо. Никто не знает, кто эти будущие разработчики приложений для
Android, и, возможно, они еще даже не написали свою первую строчку на Java.

Тогда почему разработчиками для Android до сих пор не стали все? Вероятно, есть
люди, которые не разделяют мое восхищение процессом создания программного
обеспечения, которое может сделать жизнь лучше, но я предполагаю, что если вы
читаете данную книгу, вам тоже это интересно!

Первый камень преткновения для новичков

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

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

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

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

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

Как Java и Android работают вместе

Прежде чем мы начнем наше путешествие в мир Android, нам нужно понять, как
Android и Java работают совместно. Android — довольно сложная система, но вам
не нужно глубоко разбираться в ней, чтобы создавать потрясающие приложения.

28 Глава 1

После написания программы на Java для Android мы нажимаем кнопку, и наш код
преобразуется в другую форму — понятную Android. Эта другая форма называется
байт-кодом, а процесс преобразования — компиляцией.

Затем, когда пользователь устанавливает наше приложение, байт-код переводится
другим процессом, известным как Android Runtime (ART), в машинный код. Это
самый быстрый из возможных форматов выполнения. И если когда-нибудь люди
говорили вам, что не следует использовать Java из-за ее медлительности, знайте:
они ошибаются. Java позволяет программировать быстро, а затем при установке
превращается в машинный код, быстрый для устройства. Что может быть лучше?

Система ART обеспечивает сверхбыстрое выполнение наших приложений, а также
снижает расход заряда батареи. Более того, ART не просто создает машинный код,
а затем расслабляется и ничего не делает, — она предоставляет нашему приложе-
нию хуки, которые улучшают управление памятью при работе приложения. Это
позволяет писать приложения более эффективно и, как мы увидим в главе 12, более
легко, обрабатывая критические аспекты управления памятью.

ART — это программная система, написанная на другом языке, работающая на
специально адаптированной версии операционной системы Linux. Поэтому то, что
пользователь видит в Android, — это просто приложение, работающее в еще одной
операционной системе.

Android — это набор подсистем. Типичный пользователь Android не видит опера-
ционную систему Linux и ничего не знает о наличии ART, но именно они и застав-
ляют всё работать.

Задача Linux-части системы — скрыть сложность и разнообразие аппаратного и
программного обеспечения, на котором работает Android, в то же время раскрыв
все его полезные функции. Раскрытие функций работает двумя способами:

1. Система должна иметь доступ к аппаратному обеспечению, что она и делает.

2. Доступ должен быть удобным для программистов и простым в использовании,
что достигается благодаря Android API.

Далее мы поговорим об Android API.

ПРИМЕЧАНИЕ
Эта книга посвящена изучению Java и созданию приложений для Android с нуля, по-
этому я не буду углубляться в подробности работы Android. Если же вы хотите узнать
больше, вы можете воспользоваться Википедией:

https://en.wikipedia.org/wiki/Android_(operating_system).

Что такое Android API

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

Начало работы с Android и Java 29

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

Например, следующая строка кода Java, возможно, выглядит немного пугающей на
данном этапе, но она служит хорошим примером того, как Android API помогает
нам:

locationManager.getLastKnownLocation (LocationManager.GPS_PROVIDER)

Как только вы узнаете, что эта единственная строка кода ищет доступные спутники
в космосе на их орбитах вокруг Земли, получает информацию от них, а затем из-
влекает ваши точные координаты (широту и долготу) на поверхности планеты,
мощность и глубина Android API в сочетании со скомпилированным байт-кодом
и ART становятся очевидными.

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

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

ПРИМЕЧАНИЕ
Есть много разных оценок количества строк кода, которые были введены в Android. По
одним оценкам, 1 млн, а по другим — 20 млн. Может показаться удивительным, что,
несмотря на такое огромное количество строк кода, в кругах программирования
Android известен как «легкий».

Вопрос, который мы должны задать и на который попытаемся ответить в этой кни-
ге, заключается в следующем:

Как нам использовать весь этот код, чтобы делать действительно крутые вещи?
Или, если сформулировать вопрос в соответствии с приведенной выше аналогией:
как найти и управлять педалями, рулевым колесом и люком в крыше Android API?

Ответ: с помощью языка программирования Java, т. к. Java была разработана, что-
бы помочь программистам справляться со сложностями.

Давайте немного поговорим о Java и объектно-ориентированном программирова-
нии (ООП).

Java — объектно-ориентированный язык
программирования

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

30 Глава 1

Итак, используя аналогию с автомобилем, мы могли бы задать вопрос: если произ-
водитель выпускает более одной машины в день, модифицируется ли при этом
каждая деталь для каждой машины?

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

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

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

Кроме того, мы можем сами создавать планы, а из них — объекты. Затем компиля-
тор преобразует (произведет) наше конкретное творение в байт-код. И вуаля! У нас
есть приложение для Android.

В Java план называется классом. Когда класс превращается в настоящую рабочую
«вещь», мы называем это объектом или экземпляром класса.

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

Java — это язык, который позволяет нам один раз написать код, который затем можно
применять повторно. Это очень полезно, поскольку экономит время и позволяет ис-
пользовать для выполнения задач чужой код, на написание которого у нас не хватило
времени или знаний. В большинстве случаев нам даже не нужно видеть этот код или
понимать, как он работает! И последняя аналогия: нам всего лишь нужно знать, как
использовать код, так же как нужно всего лишь научиться водить машину.

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

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

ПРИМЕЧАНИЕ
Я понимаю ваши чувства, если вы разочарованы тем, что вам не нужно видеть весь
код. Некоторые люди, узнав что-то новое, хотят узнать всё в деталях. Если вы из их
числа, то будьте уверены, что лучшее начало изучения работы Android API изнутри —

Начало работы с Android и Java 31

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

Добро пожаловать в мир объектно-ориентированного программирования — ООП!
Я буду постоянно, в каждой главе, ссылаться на ООП, а в главе 10 подробно рас-
скажу о том, как это работает.

Повторим: что такое Android

Чтобы создавать приложения для Android, мы пишем собственный Java-код, кото-
рый также использует Java-код Android API. Затем он компилируется в байт-код и
транслируется ART при установке пользователем в машинный код, который,
в свою очередь, подключается к базовой операционной системе под названием
Linux, работающей на сложном оборудовании чрезвычайно разнообразного диапа-
зона, представляющем собой различные устройства Android.

Производители устройств Android и отдельных аппаратных компонентов, очевид-
но, знают это, и создают дополнительное программное обеспечение, называемое
драйверами, которое гарантирует, что их оборудование (процессоры, графические
процессоры, приемники GPS, микросхемы памяти, аппаратные интерфейсы и т. д.)
сможет работать в операционной системе Linux, лежащей в основе Android. Байт-
код (вместе с некоторыми другими ресурсами) помещается в пакет файлов, назы-
ваемый пакетом приложений Android (Android Application Package, APK), который
необходимо запустить ART, чтобы подготовить приложение для пользователя.

ПРИМЕЧАНИЕ
Нет необходимости подробно запоминать шаги, которые проходит код при взаимодей-
ствии с оборудованием. Достаточно понять следующее: наш Java-код проходит неко-
торые автоматизированные процессы, чтобы стать приложениями, которые мы можем
опубликовать в Google Play Store.

Следующий вопрос: где именно происходит все это Java-кодирование и компиля-
ция в байт-код вместе с упаковкой APK? Давайте посмотрим на среду разработки,
которую мы будем использовать.

Android Studio

Термин среда разработки обозначает наличие всего необходимого для разработки,
настройки и готовности к работе в одном месте. Для начала нам нужны две вещи:

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

32 Глава 1

JDK. JDK включает еще больше кода других людей, который не является
Android API.

2. Существует целый ряд инструментов, необходимых для разработки под Android,
и, конечно же, нам также понадобится Android API. Весь этот набор необходи-
мых вещей известен под общим названием Android SDK. К счастью, загрузка и
установка всего одного приложения даст нам все это вместе. Данное приложе-
ние называется Android Studio.

Android Studio — это интегрированная среда разработки (Integrated Development
Environment, IDE), которая позаботится обо всех сложностях компиляции нашего
кода и связывании с JDK и Android API. После того как мы установили Android
Studio, мы можем делать все, что нам нужно, внутри этого единственного приложе-
ния и забыть о многих сложностях, которые мы обсуждали.

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

Итак, познакомимся с Android Studio поближе.

Настройка Android Studio

Настройка Android Studio довольно проста, хотя и занимает некоторое время.
Возьмите немного прохладительных напитков и начните со следующих шагов. Мы
установим Android Studio на диск D. Я выбрал диск D, потому что нам потребуется
много места (около 12 Гбайт после того, как мы всё загрузим), а диск D на многих
ПК обычно большего объема и имеет больше свободного пространства, чем диск C.
Если вы хотите установить Android Studio на диск C (или любой другой диск), эти
инструкции легко изменить.

1. Посетите страницу https://developer.android.com/studio и щелкните кнопку
Download Android Studio (Загрузить Android Studio). Начнется загрузка по-
следней стабильной версии для Windows. Вам нужно будет принять условия и
соглашения, чтобы начать загрузку.

2. Пока идет загрузка, создайте новую папку в корне вашего диска D под названи-
ем Android. Внутри папки Android создайте еще одну новую папку — Android
Studio. Вернитесь в папку Android и создайте папку с именем Projects (Проек-
ты). Здесь мы будем хранить все файлы проектов, создаваемых нами на протя-
жении всей книги. Создайте еще одну новую папку с именем Sdk, которую мы
предложим программе-установщику для установки Android SDK. Теперь у вас
должна быть папка D:\Android, которая выглядит так, как показано на рис. 1.1.

3. После завершения загрузки найдите загруженный файл. Он будет называться
android-studio-ide... Дважды щелкните файл левой кнопкой мыши, чтобы
запустить его.

4. Вам будет предложено предоставить программе-установщику права админи-
стратора, после чего вы можете щелкнуть левой кнопкой мыши Next (Далее),

Начало работы с Android и Java 33

чтобы начать установку. Убедитесь, что в окне Choose Components (Выбор
компонентов) установлены флажки как для Android Studio, так и для виртуаль-
ного устройства Android, а затем снова щелкните левой кнопкой мыши кнопку
Next (Далее) (рис. 1.2).

Рис. 1.1. Папка D:\Android

Рис. 1.2. Окно Choose Components

5. В окне Configuration Settings (Настройки конфигурации) щелкните левой кноп-
кой мыши кнопку Browse (Просмотр) и перейдите к D:\Android\Android Studio,
а затем щелкните левой кнопкой мыши кнопку ОК (рис. 1.3).

6. Щелкните левой кнопкой мыши кнопку Next (Далее), показанную на предыду-
щем рисунке. В окне Choose Start Menu Folder (Выбрать папку начального
меню) щелкните левой кнопкой мыши на Install (Установить), чтобы принять
параметр по умолчанию. Начнется первая часть установки.

7. Когда вы получите сообщение Installation Complete (Установка завершена),
щелкните левой кнопкой мыши Next (Далее). Затем вы можете щелкнуть левой
кнопкой мыши Finish (Завершить). Android Studio должен запуститься автома-
тически. Если этого не происходит, вы можете найти и запустить приложение
Android Studio из меню Пуск Windows.

34 Глава 1

Рис. 1.3. Окно Configuration Settings

8. Вы увидите сообщение, что у вас отсутствует SDK (если это не первый раз,
когда вы использовали Android Studio). Щелкните левой кнопкой мыши Next,
чтобы продолжить.

9. На этапе установки компонентов SDK — окно SDK Components Setup — нуж-
но изменить место установки. Щелкните левой кнопкой мыши в поле Android
SDK Location (Расположение Android SDK) и перейдите к D:\Android\Sdk
(рис. 1.4).

Рис. 1.4. Окно SDK Components Setup

10. Щелкните Next левой кнопкой мыши.
11. В окне Verify Settings (Проверка настроек) щелкните левой кнопкой мыши

Finish (Завершить). Android Studio загрузит еще несколько файлов и завершит

Начало работы с Android и Java 35

установку. Это может занять несколько минут или более, и у вас снова может
быть запрошено разрешение доступа к вашему компьютеру.
12. По окончании процесса щелкните Finish левой кнопкой мыши.
Вас встретит окно приветствия Android Studio (рис. 1.5).

Рис. 1.5. Окно приветствия Android Studio

Если вы готовы сразу перейти к следующему этапу, оставьте этот экран открытым.
Если хотите, можете закрыть его и запустить Android Studio из меню Пуск
Windows, как и любое другое приложение, когда будете готовы продолжить.
Далее мы поговорим о том, что включает в себя приложение для Android.

Что делает приложение для Android?

Мы уже знаем, что напишем код Java с использованием кода Java других людей,
который будет скомпилирован в байт-код и затем преобразуется в машинный код
на устройствах Android пользователей. Кроме того мы будем добавлять и редакти-
ровать другие файлы, которые также включаются в окончательный APK. Эти фай-
лы известны как ресурсы Android.

Ресурсы Android

Наше приложение будет включать такие ресурсы, как изображения, звук и компо-
новки пользовательского интерфейса (User Interface, UI), которые хранятся в от-
дельных файлах от кода Java. Мы будем постепенно знакомиться с ними по ходу
книги.

36 Глава 1

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

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

Android (или любой компьютер), конечно, не может читать и распознавать текст
так же, как человек. Следовательно, мы должны создавать наши ресурсы хорошо
организованными и заранее определенным образом. Для этого мы будем использо-
вать расширяемый язык разметки (eXtensible Markup Language, XML). XML —
огромная тема, но, к счастью, вся его цель сводится к тому, чтобы быть читаемым
как человеком, так и машиной. Изучать этот язык нам не нужно, надо просто отме-
тить (а затем соблюдать) несколько правил. Бо́льшую часть времени, когда мы
взаимодействуем с XML, мы делаем это с помощью удобного визуального редакто-
ра, предоставляемого Android Studio. Когда имя файла заканчивается расширением
.xml, это значит, что мы имеем дело с XML-ресурсом.

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

Структура кода Java в Android

Стоит отметить, что код Java, используемый в Android, структурирован. Есть мил-
лионы строк кода, которыми мы можем воспользоваться. Этот код необходимо
организовать таким образом, чтобы его было легко найти и применить. Он органи-
зован в пакеты, специфичные для Android.

Пакеты

Каждый раз, создавая новое приложение для Android, мы выбираем уникальное
имя, известное как пакет. Займемся этим чуть позже, в разделе «Создание нашего
первого приложения для Android» настоящей главы. Внутри пакетов можно созда-
вать свои подпакеты и, следовательно, группировать их вместе с другими подоб-
ными пакетами. Почти полностью точная аналогия — это известные вам папки
и подпапки.

Все пакеты, предоставляемые нам Android API, можно считать библиотеками кода.
Вот некоторые распространенные пакеты Android, которые мы будем использовать:

android.graphics;

android.database;

android.view.animation.

Как видите, они организованы и названы так, чтобы их содержимое было наиболее
очевидным.

Начало работы с Android и Java 37
ПРИМЕЧАНИЕ
Если вы хотите получить представление о глубине и широте Android API, посмотрите
список пакетов Android здесь: https://developer.android.com/reference/packages.

Классы

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

Методы

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

Рис 1.6. Представление Android API

38 Глава 1

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

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

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

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

Создание нашего первого приложения
для Android

В программировании принято, что первое приложение новичка, написанное на лю-
бом языке программирования с использованием любой операционной системы,
обычно говорит «Привет» миру. Мы быстро создадим приложение, которое делает
именно это, а в главе 2 выйдем за рамки традиции и добавим несколько кнопок,
реагирующих на нажатия пользователя.

ПРИМЕЧАНИЕ
Полный код, который должен получиться при создании приложения на данном этапе,
можно скачать по ссылке, приведенной в начале этой главы, в папке Chapter 1 (Гла-
ва 1). Однако вы не можете просто скопировать и вставить этот код! Вам все еще нуж-
но пройти этап создания проекта, описанный в данной главе (и в начале всех проек-
тов), поскольку Android Studio выполняет большую и невидимую работу. После того
как вы пройдете эти шаги и поймете, какой код пишет программист, а какой код/файлы
генерирует Android Studio, вы сможете сэкономить время и копировать и вставлять
файлы, размещенные мною в Интернете.

Итак, чтобы начать создание проекта, выполните следующие действия:

1. Запустите Android Studio так же, как и любое другое приложение. Например,
в Windows 10 значок запуска отображается в меню Пуск.

СОВЕТ
Если вам будет предложено Import Studio settings from... (Импортировать настройки
из...), выберите Do not import (Не импортировать настройки).

2. Вы увидите окно приветствия Android Studio, как на рисунке ниже. Найдите
опцию Сreate New Project (Создание нового проекта) Android Studio и щелк-
ните на ней левой кнопкой мыши (рис. 1.7).

Начало работы с Android и Java 39

Рис. 1.7. Окно приветствия Android Studio

3. Следующее окно — Select a Project Template (Выбор шаблона проекта).
4. Здесь находится несколько полезных шаблонов проектов, которые Android

Studio может сгенерировать для вас в зависимости от типа приложения, которое
вы собираетесь разрабатывать. Мы будем использовать опцию Basic Activity
(Основная активность). Android Studio автоматически сгенерирует небольшой
объем кода и набор ресурсов для запуска нашего проекта. Подробнее код и ре-
сурсы мы обсудим в следующей главе.
5. Выберите опцию Basic Activity (Основная активность). Ниже дано изображение
окна Select a Project Template (Выбор шаблона проекта) с выбранной опцией
Basic Activity (рис. 1.8).
6. Убедитесь, что выбрано Basic Activity (Основная активность), как показано на
рис. 1.8, и нажмите Next (Далее).
После этого Android Studio откроет окно Configure Your Project (Настройка
вашего проекта). Здесь нужно сделать следующее:
• дать название новому проекту;
• выбрать на компьютере место для размещения файлов проекта;
• указать имя пакета, чтобы отличать наш проект от других на тот случай, если

когда-нибудь мы решим опубликовать приложение в Play Store.
• выбрать язык программирования, который мы будем использовать. Наш про-

ект будет называться Hello World, а местом для файлов станет папка Projects,
которую мы создали в разделе «Настройка Android Studio». Имя пакета мо-
жет быть любым. Если у вас есть веб-сайт, вы можете использовать формат

40 Глава 1

com.yourdomainname. Если нет, не стесняйтесь использовать мое доменное имя
com.gamecodeschool.helloworld или придуманное вами. Это важно только
в том случае, если вы собираетесь опубликовать свой проект.

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

Переменная Значение
Name (Имя) Hello World
Package name (Имя пакета) com.gamecodeschool.helloworld
Save location (Место расположения) D:\Android\Projects\HelloWorld
Language (Язык) Java
Minimum SDK (Минимальный SDK) Оставьте это и другие значения по умолчанию

СОВЕТ
Обратите внимание, что в имени приложения есть пробел между Hello и World, но
в расположении проекта пробел отсутствует, и проект не будет работать, если он есть.

Рис. 1.8. Окно Select a Project Template

Начало работы с Android и Java 41

Рис. 1.9. Окно Configure Your Project

7. После ввода всей информации вы увидите окно Configure Your Project (На-
стройка вашего проекта) (рис. 1.9).

8. На предыдущем рисунке вы можете увидеть, что Android Studio автоматически
сгенерировала имя пакета на основе введенной информации. Мой пакет —
com.gamecodeschool.helloworld. Ваш может быть таким же или другим — это не
имеет значения.

ПРИМЕЧАНИЕ
Вы можете писать приложения для Android на разных языках, включая C ++ и Kotlin.
У каждого из них есть свои преимущества и недостатки по сравнению с Java. Освое-
ние Java станет отличным введением при изучении других языков, Java также являет-
ся официальным языком Android. Большинство популярных приложений и игр в Play
Store в настоящее время написаны на Java.

Вы также можете увидеть опцию Minimum SDK. Оставьте это значение по
умолчанию, но обратите внимание, что на момент написания оно по умолчанию
может быть для вас другим.

ПРИМЕЧАНИЕ
Мы уже знаем, что Android SDK — это набор пакетов кода, который мы будем ис-
пользовать для разработки наших приложений. Как и любой хороший SDK, Android
SDK регулярно обновляется, и каждый раз, когда он получает значительное обновле-
ние, номер версии увеличивается. Проще говоря, чем выше номер версии, тем боль-

42 Глава 1

ше новых функций вы можете использовать; чем меньше номер версии, тем на боль-
шем количестве устройств будет работать приложение. На данный момент Android
Jelly Bean предоставляет нам множество замечательных функций и почти 100 %-ную
совместимость с устройствами Android, которые используются в настоящее время.
Если в ходе изучения этой книги Android Studio предложит более новую версию API и
Android, используйте их. Если вы читаете книгу спустя несколько лет после публика-
ции, то опция Minimum SDK, вероятно, будет по умолчанию другой, но код из этой
книги по-прежнему будет работать.

9. Нажмите кнопку Finish (Завершить), чтобы запустить приложение и увидеть
свои достижения.

ПРИМЕЧАНИЕ
Когда вы создаете новый проект, Android Studio инициирует новую загрузку. Android
Studio настроит систему сборки Gradle, которую использует для управления конфигу-
рацией и развертывания проекта. Так будет только с самым первым проектом. Для
работы с этой книгой знание Gradle не требуется, но если вам интересно, вы можете
воспользоваться Интернетом, чтобы получить больше информации.

Итак, посмотрим на наше приложение в действии.

Развертывание приложения на данном этапе

Возможно, вы удивитесь, узнав, что прежде чем взять какой-либо код и начать изу-
чение Java, мы уже можем запустить наш проект. Это будет просто безликое при-
ложение, но поскольку мы будем запускать приложение довольно часто, чтобы
увидеть результат, мы сейчас узнаем, как это сделать. У вас есть три варианта:

запустить приложение на эмуляторе на вашем ПК (эмулятор является частью
Android Studio) в режиме отладки;

запустить приложение на реальном устройстве Android в режиме отладки USB;

экспортировать приложение как полноценный Android-проект, который можно
загрузить в Play Store.

Первый вариант (запуск в режиме отладки) использовать проще всего, потому что
мы уже выполнили это как часть настройки Android Studio. Если у вас мощный
компьютер, вы вряд ли заметите разницу между эмулятором и реальным устройст-
вом. Однако в этом случае касания экрана эмулируются щелчками мыши, и надле-
жащее тестирование взаимодействия с пользователем невозможно в случае с неко-
торыми приложениями, какие мы создадим далее (в частности, с приложением для
рисования). Кроме того, вам может просто нравиться время от времени тестировать
свои творения на реальном устройстве — как мне, например.

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

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

Начало работы с Android и Java 43

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

Запуск и отладка приложения на эмуляторе Android

Чтобы запустить приложение на эмуляторе Android, используемом по умолчанию,
выполните следующие простые шаги:
1. В строке меню Android Studio выберите Tools (Инструменты) | AVD Manager

(Менеджер AVD). AVD — это Android Virtual Device (Виртуальное устройство
Android, т. е. эмулятор). Вы увидите следующее окно (рис. 1.10):

Рис. 1.10. Окно AVD Manager

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

ВАЖНО
Эмулятор должен был быть установлен в соответствии с шагами, которые мы выпол-
нили ранее. Во время тестирования одной предрелизной версии я заметил, что эму-
лятор не был установлен по умолчанию. Если в окне Your Virtual Devices (Ваши вир-
туальные устройства) эмулятора нет, выберите Tools (Инструменты) | AVD Manager
(Менеджер AVD) | Create Virtual Device (Создать виртуальное устройство) | Next (Да-
лее) | R Download | Accept (Принять) | Next (Далее); после этого будет загружен и ус-
тановлен эмулятор по умолчанию. Когда установка будет завершена, нажмите Finish
(Завершить), затем Next и, наконец, снова Finish. Теперь вы можете перейти к пре-
дыдущему шагу, чтобы запустить эмулятор.

2. Щелкните зеленый значок запуска (справа), показанный на рис. 1.11, и подож-
дите, пока загрузится эмулятор.

3. Теперь вы можете щелкнуть значок запуска на панели быстрого запуска Android
Studio, как показано на следующем рисунке, и, если будет предложено, выбрать

44 Глава 1

Pixel_3a_API_30_x... (или другое название вашего эмулятора), после чего при-
ложение запустится на эмуляторе (рис. 1.12).
Готово. Так приложение выглядит на данный момент в эмуляторе (рис. 1.13). Пом-
ните, что у вас может быть (и, возможно, есть) другой эмулятор — это нормально.

Рис. 1.11. Значок запуска
Рис. 1.12. Значок запуска на панели быстрого запуска Android Studio

Рис. 1.13. Приложение
в эмуляторе на данном этапе

Начало работы с Android и Java 45

Разумеется, у нас еще много работы, прежде чем мы отправимся в Кремниевую до-
лину искать финансовую поддержку, но это хорошее начало. Сообщение на экра-
не — Hello first fragment (Привет, первый фрагмент). Фрагмент — это строитель-
ный блок многих приложений для Android, и мы будем изучать их на протяжении
всей книги. Если вы нажмете кнопку Next (Далее), то увидите новую пустую ком-
поновку, а если затем нажмете кнопку Previous (Назад) — снова увидите Hello first
fragment. Неплохо, учитывая, что мы еще не написали никакого кода.

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

ПРИМЕЧАНИЕ
В следующей главе мы увидим, как использовать ошибки и другие данные для отлад-
ки приложений.

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

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

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

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

Как создать новый эмулятор
Создать эмулятор для другого устройства Android нетрудно. В главном меню выбери-
те Tools (Инструменты) | AVD Manager (Менеджер AVD). В окне AVD Manager щелк-
ните левой кнопкой мыши Create Virtual Device (Создать виртуальное устройство).
Теперь щелкните левой кнопкой мыши по типу устройства, которое вы хотите создать:
TV, Phone, Wear OS или Tablet. Затем просто щелкните левой кнопкой мыши Next и
следуйте инструкциям по созданию нового AVD. В дальнейшем, когда вы запустите
свое приложение, новый AVD появится в качестве опции для запуска приложения.
В следующей главе мы шаг за шагом создадим новый эмулятор для планшета.

Теперь мы можем научиться загружать наше приложение на реальное устройство.

Запуск приложения на реальном устройстве

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

46 Глава 1

ПРИМЕЧАНИЕ
Большинству новых устройств драйвер не требуется. Поэтому вы можете сначала по-
пробовать выполнить следующие шаги.

Данные шаги подготовят устройство Android для отладки. Обратите внимание, что
разные производители могут структурировать пункты немного по-разному. Но
представленная далее последовательность практически полностью соответствует
включению отладки на большинстве устройств.
1. Коснитесь пункта меню Settings (Настройки) или приложения Настройки на

телефоне или планшете.
2. Следующий шаг будет немного отличаться для разных версий Android. Меню

Параметры разработчика скрыто, чтобы не отвлекать обычных пользователей.
Чтобы разблокировать это меню, нужно выполнить немного странные действия.
Коснитесь параметра Об устройстве или О телефоне. Найдите параметр Номер
сборки и нажимайте на него до тех пор, пока не получите сообщение: «Вы ста-
ли разработчиком!».

ПРИМЕЧАНИЕ
У некоторых производителей имеются разные неявные методы разблокировки меню
разработчика. Если предложенный вариант не работает, вы можете найти подходя-
щий способ в Интернете: запрос должен содержать название устройства и фразу
«Разблокировать меню разработчика.

3. Вернитесь в меню Настройки.
4. Нажмите Параметры разработчика.
5. Установите флажок Отладка по USB.
6. Подключите Android-устройство к USB-порту компьютера.
7. Щелкните в любом месте Android Studio, чтобы она обнаружила подключение

вашего устройства. Теперь нужно найти запрос Разрешить отладку по USB? на
вашем устройстве и нажать Разрешить.
8. Щелкните значок запуска на панели инструментов Android Studio, как показано
на рис. 1.14.

Рис. 1.14. Значок запуска на панели инструментов Android Studio

9. При появлении запроса нажмите OK, чтобы запустить приложение на выбран-
ном вами устройстве.

Теперь мы готовы немного изучить Java и добавить наш собственный код Java
в проект Hello World!, который мы рассмотрим в следующей главе.

Начало работы с Android и Java 47

Часто задаваемые вопросы

1. Итак, действительно ли Android — это не операционная система, а просто вир-
туальная машина, и действительно ли все телефоны и планшеты являются
машинами Linux?

Ответ. Все различные подсистемы устройства Android, включая Linux, ART,
библиотеки и драйверы, вместе составляют операционную систему Android.

2. Я до сих пор не понимаю всех этих технических терминов, таких как ART,
объектно-ориентированный, APK и т. д. Стоит ли перечитать эту главу?

Ответ. Нет, в этом нет необходимости, поскольку нам просто нужно было вве-
сти этот жаргон, и мы еще будем пересматривать его, а также делать уточнения
по мере продвижения. Если вы понимаете это, вы готовы перейти к следующей
главе. Мы будем писать код Java и создавать другие ресурсы в Android Studio,
которая с помощью JDK превратит этот код и ресурсы в настоящие приложения
для Android.

Итоги

Мы настроили нашу среду разработки Android, создали новое приложение для
Android и развернули наше приложение как на эмуляторе, так и на реальном уст-
ройстве. Если у вас еще есть вопросы без ответов (а их, вероятно, больше, чем было
в начале главы), не волнуйтесь, потому что по мере того, как мы будем углубляться
в мир Android и Java, всё будет становиться понятнее.

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

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

572 Глава 28

Форумы пользователей Android

Стоит зарегистрироваться на некоторых посвященных Android форумах и время от
времени посещать их, чтобы узнать, какие темы и тенденции актуальны с точки
зрения пользователя. Я не буду перечислять их здесь, потому что все, что требует-
ся, — это быстрый поиск в Интернете.
Если вы серьезно относитесь к теме, можете посетить некоторые конференции по
Android, где есть возможность пообщаться с тысячами других разработчиков и по-
сетить лекции. Если вас это интересует, поищите в Интернете «droidcon», «Android
Developer Days» и «GDG DevFest».

Обучение более высокого уровня

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

Каналы связи с автором

Пожалуйста, будьте на связи!

gamecodeschool.com;
facebook.com/gamecodeschool;
twitter.com/gamecodeschool;
youtube.com/c/Gamecodeschool/videos;
linkedin.com/in/gamecodeschool.

Краткое напутствие перед расставанием 573

До свидания и спасибо!

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

Возможно, вы прочитали книгу для развлечения или в надежде получить благодар-
ности за выпуск своего приложения, возможно, рассматриваете изучение книги как
шаг вперед в своей карьере программиста или действительно создадите приложе-
ние, которое покорит Google Play.

В любом случае благодарю за приобретение этой книги и желаю вам всего наилуч-
шего в ваших будущих начинаниях.

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

Предметный указатель

@ DELETE, ключевое слово SQL JSONException, класс 385
553 JSONObject, класс 385
@Override 166
double, тип переменных 179 L
A dpi, точек на дюйм 88
drawable, папка 86 layout, папка 87
activity_main.xml, файл 96 layout_weight 141
ALTER, ключевое слово SQL E LinearLayout, компоновка 106
Logcat, консоль 49
555 EditText, виджет 283 long, тип переменных 179
Android API 28 Empty Activity 78
Android Application Package, APK ◊ шаблон 80 M

31 F MainActivity.java, файл 84, 93
Android Runtime (ART) 28 manifests, папка 81
Android SDK 32 float, тип переменных 179 Margin, поле 140
AppCompatActivity 170 FragmentManager, класс 517 match_parent 139
ArrayList, класс 348 FROM, ключевое слово SQL 553 Matrix, класс 433
Array-out-of-bounds, исключение mipmap, папка 87
G Model-view-controller (MVC),
347
GitHub 570 паттерн 504
B gravity 142
N
Basic Activity 92 H
Bfxr, приложение 493 NavigationView, виджет 534
Bitmap, класс 423 HashMap 351 new, ключевое слово 248
boolean, тип переменных 180
byte, тип переменных 180 I O

C ImageView onCreate, метод 162
◊ виджет 283 onDestroy, метод 162
CalendarView 121 ◊ класс 424 onPause, метод 162
Canvas, класс 422, 425 INSERT, ключевое слово SQL onResume, метод 162
CardView 144 onStart, метод 162
char, тип 180 553 onStop, метод 162
CheckBox, виджет 289 int, тип переменных 179
Color.argb, метод 429 integer, тип SQL 553 P
colors.xml, файл 89 Intent, класс 372
Component Tree 122 Padding, отступ 140
ConstraintLayout 56 J PagerAdapter, класс 528
◊ компоновка 128 Paint, класс 423
Cursor, класс 557 java, папка 83 Palette, окно 58
Cистема координат Android 431 Java (generated), папка 85 ParticleSystem, класс 470
JDK 32 private, модификатор доступа
D JSON (JavaScript Object Notation)
241, 242
default, модификатор доступа 383 Profiler 484
241, 242