Java для Android

1. Java и Android
2. Java для Android - это другое
3. Прогулка по Java на Android
4. Не так паранормальная активность
5. Позволяет перейти моделирования
6. Модификаторы доступа
7. Фрагменты
8. Интерфейсы
9. Аннотации
10. Куда пойти отсюда?

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

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

• Чем приложение на Android отличается от Java-программы на ПК
• Как использовать объектно-ориентированное программирование для Android
• Что такое интерфейс Java и как вы можете использовать его для взаимодействия с другими частями вашего приложения
• Что такое аннотации Java и как они предоставляют дополнительную информацию о частях вашего приложения

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

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

Возьмите чашку своей любимой «Java» и приготовьтесь к волшебному туру по языку - в стиле Android!

Java и Android

Интересный факт: Android не использует «чистую» Java! Это может звучать странно, потому что, когда вы сравниваете код из традиционной программы на Java с аналогичным кодом из приложения для Android, вам будет трудно увидеть разницу.

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

Главная привлекательность Java - способность «писать один раз, бегать везде». Этот язык продается как серебряная пуля для дорогостоящего процесса переноса программного обеспечения с одной платформы на другую.

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

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

Хотя машинный код выполняется быстро, он ограничен, потому что он нацелен на платформу, на которой он работает. Если вы когда-нибудь задумывались, почему программа, написанная для платформы iOS, не работает только на Windows, это одна из причин.

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

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

И теперь вы можете понять, почему большинство программ на Java запрашивают загрузку Java Runtime Environment (JRE), когда у вас ее нет - это виртуальная машина по умолчанию для большинства платформ.

Java для Android - это другое

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

Примечание : AheadT Time Compilation (AoT) - это концепция, используемая во многих языках программирования. Вы можете прочитать больше об этом в Википедии ,

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

Однако, в отличие от ART, Dalvik не компилировал байт-код в машинный код до времени выполнения - используя подход, известный как компиляция Just in Time (JIT). Этот процесс намного ближе к тому, который используется в виртуальных средах Java на ПК.

Android Froyo (2.2) увидел улучшение, когда Dalvik получил возможность профилировать приложение во время выполнения для часто используемых частей Dalvik Bytecode. Затем эти инструкции были постоянно переведены в машинный код Dalvik для повышения скорости работы приложения.

Примечание . Компиляция на основе трассировки точно в срок (JIT) не является уникальной для Java, и еще раз, Википедия делает хорошую работу, объясняя это.

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

Изменения в Байт-коде ограничивают мобильность приложения, тем самым сводя на нет одно из обещаний языка Java: «Пиши один раз, беги везде».

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

Android предлагает подмножество того, что обеспечивает Java, и то, что оно предоставляет, предназначено только для Android.

Прогулка по Java на Android

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

Все объекты в Android в некоторой форме наследуются от класса Object, основываясь на его функциях, обеспечивающих специализированное поведение и функции. Посмотрите на некоторые объекты, доступные через Android API ; вы можете видеть иерархию, которую каждый объект наследует, и все они в конечном итоге наследуют Object.

Не так паранормальная активность

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

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

открытый класс MainMenuActivity расширяет Activity {}

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

Вы можете создать внешний вид своей деятельности, иначе говоря Layout , одним из двух способов:

• Объявите это в файле XML
• Программно создать его в классе Java

Более распространенный подход - создание макета в XML-файле. Вы бы использовали программный подход, если вам нужно адаптировать некоторые аспекты вашего макета.

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

В следующем фрагменте кода показано, как указать, что действие должно определять его внешний вид с использованием XML-макета в файле res / layout / activity_main_menu.xml .

открытый класс MainMenuActivity extends Activity {// 1 @Override protected void onCreate (Bundle saveInstanceState) {super.onCreate (saveInstanceState); // 2 setContentView (R.layout.activity_main_menu); // 3}}

Посмотрите на это по крупицам:

1. Сначала вы переопределяете onCreate (), один из методов, доступных вам в Activity. Он запускается при создании вашей активности, давая вам достаточно времени для настройки всего, что вам нужно. Часто это первый метод, который вы создаете для действия.
2. Затем вы вызываете реализацию onCreate () суперкласса, чтобы убедиться, что выполняется любая настройка, необходимая для Activity. Это обязательный шаг. Если вы этого не сделаете, ваше приложение упадет с предупреждением об исключении.
3. Наконец, вы указываете своей активности показывать экран с помощью setContentView (), передавая макет, на который ссылается R.

Примечание . R - это специальный класс, сгенерированный Android для различных ресурсов вашего приложения. Это может быть макет экрана, как вы видите выше, или это может быть что-то вроде локализованной строки, изображения или анимации. Android генерирует R при сборке, так что вам не следует изменять его вообще. Больше информации об этом доступно от developer.android.com ,

XML-макет, скорее всего, будет включать элементы, которые составляют пользовательский интерфейс. Вы получаете доступ к этим элементам через R в Activity, например так:

открытый класс MainMenuActivity расширяет Activity {TextView mTextView; Кнопка mButton; @Override protected void onCreate (Bundle saveInstanceState) {super.onCreate (сохраненныйInstanceState); setContentView (R.layout.activity_main_menu); mTextView = (TextView) findViewById (R.id.textview_main_menu); mButton = (кнопка) findViewById (R.id.button_main_menu); }}

Ключевым аспектом является findViewById (), который ищет в макете XML объекты представления, указанные в их идентификаторе, что позволяет вам манипулировать ими из Java. Обратите внимание, что вы должны типизировать каждый вызов в соответствующий подкласс View, поскольку findViewById () возвращает только объект View - корневой объект, от которого наследуются все компоненты пользовательского интерфейса.

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

открытый класс MainMenuActivity расширяет Activity {TextView mTextView; Кнопка mButton; @Override protected void onCreate (Bundle saveInstanceState) {super.onCreate (сохраненныйInstanceState); setContentView (R.layout.activity_main_menu); mTextView = (TextView) findViewById (R.id.textview_main_menu); mButton = (кнопка) findViewById (R.id.button_main_menu); mButton.setOnClickListener (new View.OnClickListener () {@Override public void onClick (View v) {mTextView.setText ("Hello World");}}); }}

Приведенный выше код запускается onClick () каждый раз, когда нажимается ваша кнопка. В onClick () вы указываете вашему TextView, изначально пустому, чтобы показывался текст «Hello World».

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

Позволяет перейти моделирования

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

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

Типичная модель выглядит примерно так:

открытый класс ReminderList {private ArrayList mReminderArrayList; public ReminderList () {mReminderArrayList = new ArrayList <> (); } public void setReminderArrayList (ArrayList RemderArrayList) {this.mReminderArrayList = RemderArrayList; } public ArrayList getReminderArrayList () {return mReminderArrayList; } public void removeLastItemFromList () {if (! mReminderArrayList.isEmpty ()) {mReminderArrayList.remove (mReminderArrayList.size () - 1); }}}

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

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

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

Модификаторы доступа

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

частный ArrayList mReminderArrayList; public void setReminderArrayList (ArrayList RemderArrayList) {this.mReminderArrayList = RemderArrayList; }

Обратите внимание на частные и публичные ключевые слова? Это модификаторы доступа, и они отвечают за указание того, какие элементы вашего класса модели доступны для других классов, что помогает инкапсулировать ваши объекты.

• Общедоступный - доступен всем остальным объектам. Открытые методы и переменные формируют API класса.
• Частное - доступно только для этого объекта. Даже недоступно для подклассов.
• Защищенный - доступный для этого объекта и его подклассов. Недоступно для любых других объектов.

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

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

Фрагменты

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

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

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

Следующий код создает фрагмент из файла макета в файле res / layout / фрагмент_embedded.xml :

открытый класс EmbeddedFragment extends Fragment {@Override public View onCreateView (inflater LayoutInflater, контейнер ViewGroup, Bundle saveInstanceState) {// Завышение разметки для этого фрагмента return inflater.inflate (R.layout.fragment_embedded, container, false); }}

Сначала вы расширяете свой класс для наследования поведения фрагмента, а затем используете один из его методов жизненного цикла, а именно onCreateView (), для настройки фрагмента. Затем вы возвращаете макет, чтобы показать для этого конкретного фрагмента.

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

private void updateFragment () {EmbeddedFragment фрагмент = (EmbeddedFragment) getFragmentManager (). findFragmentById (R.id.fragment_embedded); фрагмент.setTextViewText («Привет, маленький фрагмент»); }

Поскольку фрагмент существует внутри действия, вы получаете к нему доступ с помощью findFragmentById и идентификатора, определенного в XML. Затем вы можете легко вызвать открытые методы фрагмента, как показано в приведенном выше примере, setTextViewText ().

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

Интерфейсы

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

Теоретически, фрагменты должны интересоваться только своей целью и не должны знать, что они существуют рядом с другими; деятельность является вдохновителем в некотором смысле. Это единственный, кто имеет доступ ко всем фрагментам и знает, что они делают.

Это требует функции Java, известной как интерфейсы .

Интерфейс похож на класс, но без реализации. Вместо этого он определяет публичный API. Классы могут затем реализовать эти интерфейсы, и ваш код больше не полагается на конкретные реализации классов, вместо этого зная только, что «это неизвестный объект, для которого я могу вызывать эти методы интерфейса».

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

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

В Android интерфейсы полезны для облегчения связи фрагмента с активностью или фрагмента с фрагментом. Это работает так:

открытый класс EmbeddedFragment extends Fragment {// 1 OnItemInListSelectedListener mCallback; // 2 открытый интерфейс OnItemInListSelectedListener {public void onItemInListSelected (int position); } @Override public void onAttach (Activity Activity) {super.onAttach (Activity); // 3 try {mCallback = (OnItemInListSelectedListener) activity; } catch (ClassCastException e) {throw new ClassCastException (activity.toString () + "должны реализовать OnItemInListSelectedListener"); }} @Override public View onCreateView (Inflater LayoutInflater, контейнер ViewGroup, Bundle saveInstanceState) {return inflater.inflate (R.layout.fragment_embedded, container, false); }}

Посмотрите на это подробно:

1. Во фрагменте вы объявляете переменную-член для хранения пользовательского объекта, который реализует OnItemInListSelectedListener, и называете его mCallback.
2. Затем вы создаете интерфейс и объявляете необходимые методы - в вашем интерфейсе может быть много методов.
3. В onAttach (), методе жизненного цикла фрагмента, вы проверяете, соответствует ли активность, к которой прикреплен ваш фрагмент, OnItemInListSelectedListener. Если нет, то это не может служить вашим целям, и у вас есть проблема. ClassCastException описывает это во время выполнения. Лучше всего сообщить об этом себе и другим программистам, чтобы вы могли уловить проблему раньше.

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

открытый класс MainMenuActivity расширяет Activity, реализует EmbeddedFragment.OnItemInListSelectedListener {... public void onItemInListSelected (int position) {// Получив сообщение от фрагмента, вы сделаете что-то аккуратное здесь}}

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

Это сложная часть, но вы все еще не сообщаете фрагмент за фрагментом. Допустим, вы определили второй фрагмент, ListDetailFragment , с идентификатором frag_list_detail и методом с именем showListItemDetails (int) . Чтобы заставить их говорить, вы просто делаете то, что делали ранее, чтобы установить активность для фрагментации сообщений одним из открытых методов фрагмента:

public void onItemInListSelected (int position) {ListDetailFragment listDetailFragment = (ListDetailFragment) getFragmentManager.findFragmentById (R.id.fragment_list_detail); listDetailFragment.showListItemDetails (положение); }

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

Аннотации

Вы заметили эти специфические строки кода над некоторыми именами методов в этой статье?

@Override protected void onCreate (Bundle saveInstanceState) {super.onCreate (сохраненныйInstanceState); }

Эти слова с префиксом @ являются аннотациями . Они предоставляют дополнительную информацию на различных этапах приложения. Аннотации предоставляют компилятору дополнительную информацию во время выполнения или даже для генерации дополнительного кода.

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

Другая известная аннотация - @TargetApi . Он существует, чтобы ваши методы могли указать, что они предназначены для использования в конкретной или более новой версии Android. Использование метода с @TargetApi, для которого установлена ​​более высокая версия, чем текущая цель вашего приложения, заставит компилятор жаловаться на то, что вы используете функциональность, недоступную для вашей версии Android.

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

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

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

Куда пойти отсюда?

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

Вы кратко ознакомились с этими темами:

• Виртуальная машина Android. Одним из ключевых отличий Java для Android от стандартной Java является процесс компиляции и виртуальные машины.
• Использование POJO. Простые старые объекты Java широко используются в Android для формирования основы объектов модели.
• Модификаторы доступа. Это ключ к тому, чтобы сделать ваш код читабельным и легко рассуждать.
• Интерфейсы. Чрезвычайно важная тема в Android, так как они находятся в более широком мире Java. Ссылка на объекты через интерфейсы, а не на конкретные реализации классов, действительно поможет отделить код и создать компоненты многократного использования.
• Аннотации. Специфичные для Android аннотации Java, которые вы будете использовать прямо с первого дня.

Там нет замены для фактического создания приложения; создание приложения и экспериментирование с некоторыми концепциями, продемонстрированными здесь, и посмотреть, что работает, а что нет.

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

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

Робот Android воспроизводится или модифицируется из работы, созданной и распространяемой Google и используемой в соответствии с условиями, описанными в Лицензии на атрибуцию Creative Commons 3.0.

Похожие

Комментарии