Мобильная разработка - одна из самых динамично развивающихся отраслей IT индустрии. Тенденция к этому, несомненно, сохранится. В этих реалиях умение писать мобильные приложения это лишь малая часть профессиональной разработки. Нужно уметь писать красивый отказоустойчивый код с понятной чистой архитектурой и полным разделением логики. Код, который будет понятен как книга любому читателю. Так же, необходимо знать все современные подходы разработки Android приложений, разбираться в хороших и плохих "новинках" Android разработки. Обо всем этом вы узнаете при прохождении нашего курса. Если вы хотите быть модным, современным и профессиональным Android-разработчиком, то вы обязаны пройти этот курс! Курс создан для тех, кто хочет начать разрабатывать Android - приложения. Соответственно, задачи курса: 1) Познакомить с платформой Android. 2) Познакомить с интегрированной средой разработки - Android Studio. 3) Разобраться в структуре проекта. 4) В общем изучить компоненты Android приложения. 5) Изучить UI составляющую приложений - Activity, Fragment, их жизненный цикл. 6) Изучить элементы интерфейса, предоставляемые Android SDK. 7) Разобраться с хранением простых строковых данных в файлах Preferences.
Краткое знакомство с часто встречающимися понятиями
Loading...
From the course by Moscow Institute of Physics and Technology
Быстрый старт в разработке Android-приложений
33 оценки
From the lesson
Первые шаги в Android-разработке
На этой неделе вас ждёт знакомство со средой разработки и структурой проекта, а также работа с эмулятором.
Meet the Instructors
Магометов Азрет
Тайчинов Марат
[БЕЗ_ЗВУКА] Итак, в этом видео я бы хотел
вкратце обсудить некоторые термины, чтобы уже полностью развязать вам руки
и вы могли спокойно экспериментировать с разработкой приложений.
Подробнее о каждом из этих понятий, сущностей,
терминов мы поговорим на последующих уроках.
Сейчас просто краткое знакомство, чтобы вы были в курсе и не отвлекались.
Итак, первое, про что я хочу рассказать, это работа с ресурсами.
Смотрите, каждый раз, когда вы добавляете
новый ресурс в [НЕРАЗБОРЧИВО] ваших ресурсов,
для нее генерируется уникальный идентификатор.
Давайте рассмотрим на примере.
Смотрите, заходим в activity_launch,
видим код нашей Activity.
И Studio подсказывает нам, что текст у нас захардкожен,
что неплохо было бы вместо текста Hello Android!
использовать ссылку на ресурс, на строковый ресурс.
Давайте воспользуемся этим советом, потому что это, в конце концов, правильно.
Правильно хранить все строковые ресурсы в одном файле strings,
вместо того чтобы хардкодить их, а потом при изменении искать по всем файлам,
переименовывать, переделывать, переписывать.
Это абсолютно неправильно и трудозатратно.
Плюс если вы вдруг решите перевести свое приложение с английского на французский,
вам достаточно будет перевести только файл strings,
так как все строки находятся в нем.
Наводим на значения атрибута text Hello Android!
Нажимаем Alt, нажимаем Enter и видим контекстное меню.
В нем выбираем Extract string resource.
Нажимаем Enter, вбиваем название ресурса, которое нам нужно, и значение ресурса.
В принципе здесь прямо сейчас меня все устраивает.
Щелкаем OK.
Значение атрибута поменялось.
Теперь вместо захардкоженного Hello Android!
мы видим ссылку на этот ресурс.
Причем ссылка вида: тип ресурса, собачка,
string и название ресурса Hello Android!
Давайте перейдем в файл strings и посмотрим на этот ресурс.
Перейти мы можем, либо щелкнуть на strings,
либо зажав Ctrl либо [НЕРАЗБОРЧИВО], и щелкнуть прямо на ресурсе.
Видим файл strings тот
самый и название ресурса Hello Android!
значение Hello Android!
Давайте поменяем значение Hello Android!
from RES.
Переключаемся обратно на activity_launch и видим,
что текст изменился.
То есть мы изменили текст ресурса,
он автоматом изменился во всех местах, где этот ресурс использовался.
Соответственно это еще одно преимущество использования ресурсов,
вам не нужно копировать все по сотне раз.
Просто один раз вписываете ресурс в ресурсах
и используете везде ссылку на этот ресурс, там, где вам нужно.
Дальше, ресурсов у нас множество типов,
и каждый из них, во-первых, хранится в своей собственной папке,
у некоторых специальное название папок, у некоторых свободное название папок.
И все переиспользованные ресурсы крайне желательно на уровне
почти обязательно именно хранить в ресурсах.
Дальше, мы узнали, как обращаться к ресурсам из xml файла, то есть @string.
А как обращаться к ресурсам из java-файла?
В принципе, почти все то же самое.
В Activity мы можем написать getString — это метод,
который на вход принимает указатель на наш ресурс.
Указатель типа R.string.
название ресурса — в нашем случае Hello Android!
Ставим точку с запятой.
Что такое R.string и почему именно так это все выглядит?
Каждый раз, когда вы добавляете новый ресурс в ваши ресурсы
(я прошу прощения за тавтологию, просто иначе никак),
для него генерируется уникальный идентификатор, уникальный указатель.
Этот идентификатор имеет численный тип, и он хранится
в классе R в своем собственном подмножестве.
В нашем случае это string.
Давайте попробуем создать другой ресурс и посмотреть,
как поведет себя студия в этом случае.
Переходим на Colors.
И давайте создадим новый цвет.
Пишем Color, название Red,
никакой непредсказуемости тут нет,
просто создаем красный цвет.
Возвращаемся на LaunchActivity и попробуем
обратиться к этому цвету из java-кода.
getColor(R.
color.red); точка с запятой.
Как мы видим, все буквально то же самое, просто один в один.
Процесс следующий: добавляем ресурс,
студия для него сама генерирует указатель,
указатель находится в файле R в классе R в соответствующем подмножестве.
Если это цвет, то он будет в R.color, если это строка, в R.string.
Среди других вариантов R., и смотрим цвет, строки, анимации,
атрибуты, булево значение, отступы,
то есть отступы между элементами и размеры шрифтов,
drawable — картинки, id — про id мы поговорим чуть-чуть попозже,
целочисленные значения integer, R layout — вот он,
мы уже с ним познакомились вскользь, mipmap — тоже про это я вам говорил,
это иконка, с которой запускается наше приложение с экранного устройства,
стили, styleable — это добавляемые атрибуты для
своих собственных view-элементов, попозже поговорим.
Отлично.
Студия подчеркивает getColor,
потому что Cal requires API level 23, то есть это то,
про что я говорил, когда говорил про выбор минимального уровня API.
То есть мы не можем просто вызвать getColor,
потому что конкретно этот метод появился в 23-м API.
А у нас минимальное API 19.
Поэтому не исключено, что приложение будет работать на 19-м, 20-м,
21-м, 22-м API, и вызов этого метода вызовет ошибку.
Можем нажать Alt + Enter,
и Surround with — стандартный метод на проверку.
Если текущая версия устройства операционной системы,
находящейся на устройстве, больше, чем M Marshmallow, то вызываем этот код.
Либо, как я также говорил, мы можем воспользоваться
методом из библиотеки поддержки.
И выглядит он так: ContextCompat, Compat указывает на то,
что класс из библиотеки поддержки, про это я тоже говорил,
getColor this вместо Context и R.color.
red.
То есть этот метод не ругается на то,
что у нас версия API неправильная.
И мы плавно переходим к следующему понятию,
следующему термину — это Context.
Про Context тоже будет отдельно сказано в своем уроке,
в уроке, где мы знакомимся с основными сущностями Android.
Сейчас же достаточно знать то, что Context — это глобальная точка ресурса,
это такой очень мощный, скажем так, очень много умеющий объект.
Он может буквально все.
Это и доступ к ресурсам, и создание view-элементов прямо в коде,
и доступ к возможностям телефона и тому подобное.
Поэтому конкретно этот метод просит использовать Context,
просит передавать ему Context.
Другой вопрос, почему вместо Context мы передаем this.
Дело в том, что activity, а this здесь указывает именно именно на
Activity является одним из потомков контекста, одним из наследников контекста.
То есть если мы будем щелкать на extends,
все дальше-дальше-дальше, мы в конце концов упремся в контекст.
Поэтому во всех методах, которые принимают контекст,
можно передавать Activity (либо this,
либо activity.this) — я могу показать это:
LaunchActivity.this.
Activity может передавать себя вместо контекста — методы,
которые требуют контекста.
Окей, у меня есть Java-код, вот логика в этом коде,
и есть отдельно — давайте я закрою, чтобы не мешалось все.
И у меня есть отдельно XML-разметка.
Вопрос: как мне обратиться к View-элементам — к кнопке,
к тексту, которые у меня определены в XML-разметке — из Java-кода.
Все достаточно просто: когда мы
определяем View-элемент в разметке, мы обязательно
указываем — и если планируется обращаться к нему из Java-кода,
мы указываем параметр id, атрибут id.
adroid: id @+id/ и само уже id.
@+id означает, что мы добавляем новое id.
Соответственно, вместо button
мы можем написать все, что нашей душе угодно, допустим btn_click.
Отлично.
И вместо TextView тоже напишу tv_text.
Все, теперь мы, я и вы, абсолютно уверены,
что если я встречу в коде tv_text или btn_click,
то я буду знать, что эти TextView создал я,
это то, что мне именно нужно, я узнаю.
Так, здесь Studio подчеркивает красным,
потому что я переименовал id-шник, но ничего страшного.
Ctrl + C, Ctrl + V.
Все, никаких проблем, LaunchActivity.
Так, обращаемся к View-элементам из Java-класса.
Начнем с кнопки.
Процесс следующий — он не
меняется ни для какого элемента отдельного.
Во-первых, мы определяем тип View-элемента.
У нас это кнопка.
Пишем: тип класса — Button, название — nBtnClick,
опять же любое, что нам нужно.
И называем метод findViewById,
findViewById — вот он, — в который
мы передаем указатель на нашу кнопку,
передаем id, которое определяли в XML-layout.
И, как, вы наверное, уже догадались, указатель на кнопку тоже
хранится в R-классе: R .id.btn_click ; Отлично.
Да, кстати, третья Studio поддерживает SmartCast,
то есть раньше, когда мы обращались к View-элементам,
нужно было еще кастовать найденный элемент к нужному типу.
Сейчас это не нужно.
Раньше findViewById возвращал просто View,
а View — это класс-родитель для всех View-элементов,
для всех элементов интерфейса.
Сейчас он возвращает T extends View и этот метод
определенного [НЕРАЗБОРЧИВО] Activity.
Дальше стандартная Java-тема, что переменные, определенные в методе,
видны только в этом методе.
Если мы хотим, чтобы наша кнопка была видна по всей
Activity — предположим, что у нас тут очень много методов,
то ее нужно переделать из переменной метода в переменную поля.
Делается это очень просто: Ctrl + C, Ctrl + V.
Определяем переменную вне всех классов в теле, — ой!
— вне всех методов в теле класса.
Соответственно, тут убираем nButton.
Вот и все.
Кстати, надо убрать [НЕРАЗБОРЧИВО].
Теперь хорошо — мы обратились к кнопке,
и я хочу проверить, что эта кнопка — то именно та самая кнопка.
И проще всего, на мой взгляд, это проверить с помощью
добавления какого-либо функционала на нажатие на эту кнопку.
И для определения нажатия в Android используется
стандартная стандартный Java-механизм с listener'ами, то есть со слушателями.
И выглядит это следующим образом: nBtnClick.setOnClickListener
(new) — Ctrl, пробел — View.OnClickListener.
Что вообще происходит?
У класса View, который является родителем всех
View-элементов всех элементов интерфейса — уже это говорил.
Имеется поле OnClickListener, и setOnClickListener, метод
setOnClickListener записывает текущий OnClickListener, аргумент, в это поле.
И при нажатии на кнопку выполняется
вызов метода onClick этого listener.
То есть если убрать всю мишуру,
то при нажатии на эту кнопку выполнится вот этот метод.
Давайте что-нибудь попробуем сделать.
Мы можем изменить текст на TextView-элементе,
то есть при нажатии на эту кнопку поменяется этот текст.
Давайте попробуем это сделать.
Во-первых, вам нужно обратиться к этому тексту.
И опять же private TextView mText.
Дальше стандартно
mText =
findViewById(R.id.tv _text),
то есть тот id-шник, который мы ему прописали.
Хорошо.
А в методе onClick — mText.setText и текст,
который мы хотим задать этой кнопке.
Причем мы можем задать текст как хардкодом,
что неправильно — Studio уже ругается, — либо мы можем
обратиться к тексту из,
через метод GetString обратиться к тексту из ресурсов.
Давайте так и сделаем.
Создадим новый ресурс: string new_text,
закрываем, закрываем,
this text is new.
Нормально.
LaunchActivity, и давайте обратимся к этому тексту:
new_text — это очень удобно.
И загоним ее в переменную string.
Выделяем строку кода,
нажимаем Alt, CMD либо Ctrl и V.
И я рекомендую вам
выучить как можно больше шоркатов,
то есть комбинаций клавиш для Studio — чем больше, тем лучше.
Так, кстати, шорткаты можно найти тут: Help,
Keymap Reference — открывается сайт, где будут шорткаты.
Отлично.
Дальше.
Да, в наше TextView мы загоняем текст, который мы строку текста,
которую мы забрали из ресурса: newString.
Да, и, так как мы обращаемся к переменной
из коллбэка — этот метод onClick называется коллбэком,
— то эта переменная обязательно должна быть final,
то есть при компиляции кода JVM должна четко знать,
что эта переменная не изменится, пока мы обращаемся к ней.
Меньше слов, больше дела — давайте запустим.
Нажимаем на Run, переключаемся на наш эмулятор.
Нажимаем на кнопку CLICK, — бац!
— текст поменялся.
Хорошо, окей, Bundle — где мы могли видеть Bundle?
А вот он: onCreate, метод onCreate
принимает на вход Bundle savedInstanceState.
Что такое Bundle?
Bundle — это своего рода обертка над массивом данных,
и он используется для, — эта обертка, Bundle,
используется для передачи данных либо для сохранения
и считывания каких-либо значений, Давайте, посмотрим, как это работает.
Давайте создадим Bundle: bundle = new Bundle(); И
просто вызываем
методы: putString и значения в Bundle хранятся с помощью
механизма KeyValue, то есть так же, как они хранятся в HashMap.
Я пишу ключ KEY,
и я пишу значение.
[ШУМ] Помимо
строкового типа Bundle поддерживает byte,
char, float, integer,
integer array — в принципе, все примитивные типы,
— массивы этих примитивных типов и строки.
Что еще?
Еще он поддерживает Serializable и Parcelable — это специальный тип,
который позволяет объекту класса сохранять свое состояние.
То есть если наш класс помечен как Serializable либо Parcelable,
то он его можно сериализовать и передавать в этом сериализованном виде в,
допустим, в другой Activity.
То есть Bundle используются для передачи данных еще в другой Activity.
И потом в другом Activity просто развернуть, десериализовать этот
файл и получить его в том же состоянии, в котором мы его оставили.
Разница между Serializable и Parcelable в том, что Serializable — это стандартный
Java-механизм, и он использует рефлексию для работы.
Из-за этого он ощутимо медленнее.
Parcelable — это механизм, который появился в Android.
В нем мы уже сами прописываем, как что сериализовать и десериализовать.
То есть мы можем сказать, что нет, я не хочу,
чтобы вот эти два-три поля класса были сериализованы.
Или при десериализации я хочу, чтобы эти поля класса принимали вот это значение,
а не то, которое они имеют на данный момент.
Вот, в принципе и, наверное, все.
Ознакомьтесь с нашим каталогом
Присоединяйтесь бесплатно и получайте персонализированные рекомендации, обновления и предложения.
Coursera делает лучшее в мире образование доступным каждому, предлагая онлайн-курсы от ведущих университетов и организаций.
© Coursera Inc., 2018 Все права защищены.
