Наша цель в этой серии — узнать о разработке Android SDK. Итак, мы изучили инструменты разработки, посмотрели на структуру проекта приложения для Android, начали создавать пользовательский интерфейс и реагировали на взаимодействие с пользователем. В этом руководстве мы рассмотрим основные структуры и концепции Java, которые необходимо знать для начала разработки приложений для Android.
Вступление
Если вы уже знакомы с Java, вы можете игнорировать этот раздел. Если вы плохо знакомы с языком или не знакомы с ним, тогда в этом руководстве будет указано, что вам нужно выучить, чтобы продолжить работу с Android. Этот учебник сам по себе недостаточен, чтобы научить вас Java с нуля, но он послужит учебником для начинающих. Вы должны следовать за учебником с дополнительным изучением Java по мере необходимости.
Мы не будем тратить слишком много времени на изучение деталей этого руководства, но если вы боретесь с какой-либо из этих концепций, ознакомьтесь с Oracle Java Tutorials . Это обширное руководство по языку, доступное для начинающих. Не пугайтесь, если вы сначала чувствуете себя немного ошеломленными тем, что мы расскажем в этом уроке, это будет иметь больше смысла, как только вы начнете реализовывать структуры в проектах Android.
1. Синтаксис Java
Шаг 1
Вы уже видели небольшой синтаксис Java в нашем проекте Android, но для ясности давайте начнем другой проект. Вместо проекта Android, на этот раз мы будем использовать Java, чтобы вы могли легко увидеть используемые нами структуры. Откройте Затмение. Нажмите кнопку «Новый». В появившемся мастере прокрутите вниз до папки Java и раскройте ее. Выберите «Java Project» и нажмите «Далее».
Введите «MyJavaProject» в качестве имени проекта и нажмите «Готово». Затем Eclipse создает ваш новый проект в рабочей области. В Package Explorer разверните новую папку проекта. Щелкните правой кнопкой мыши на «src» и выберите «New», затем «Class». Введите «MyMainClass» в поле «Имя». Поставьте галочку напротив «public static void main» и нажмите «Finish».
Eclipse создает ваш класс и открывает его в редакторе. Не обращайте большого внимания на структуру проекта или существующее содержание класса, потому что ваши проекты Android будут иметь различную структуру. Вы можете использовать этот проект для работы над своими навыками Java-кодирования, проще запускать и тестировать код, который вы здесь пишете, чем с помощью приложения для Android, и вы можете сосредоточиться на синтаксисе Java.
Строка «public static void main», которую вы видите в файле класса, является методом main. Все, что находится внутри этого метода, выполняется при запуске приложения. Содержимое метода — это то, что появляется в фигурных скобках после «public static void main (String [] args)». Eclipse, возможно, сгенерировал строку «делать» — просто игнорируйте ее. Создайте новую строку после нее, и мы добавим туда наш код.
Шаг 2
В Java переменная может хранить значение данных, такое как текстовая строка или число. Когда вы создаете или «объявляете» переменную в Java, вы должны указать тип данных в ней и дать ей имя. Введите следующее:
|
1
|
int myNum;
|
Эта строка объявляет целочисленную переменную. Мы можем объявить переменную и присвоить ей значение, расширив строку:
|
1
|
int myNum = 5;
|
Теперь мы можем обратиться к этой переменной, используя ее имя. Затем добавьте следующую строку, записав значение переменной в консоль вывода:
|
1
|
System.out.println(myNum);
|
Как правило, вы не будете записывать данные в системный вывод в своих приложениях для Android, а вместо этого будете использовать представление LogCat. Однако запись в вывод таким способом является удобным способом проверки вашего кода Java.
Шаг 3
Давайте запустим приложение. Процесс немного отличается для приложений Android, но мы вернемся к этому позже в этой серии. Выберите «Выполнить», затем «Выполнить настройки». Выберите «Java-приложение» в списке слева и нажмите кнопку «Новая конфигурация запуска» над ним. Eclipse автоматически выбирает ваше новое Java-приложение, если оно единственное, которое у вас есть. В противном случае выберите его с помощью кнопки «Обзор».
Нажмите «Выполнить», чтобы запустить приложение. Вы должны увидеть номер пять, записанный в виде консоли под редактором. Вы можете использовать эту технику для тестирования вашего Java-кода по мере его изучения.
Вы можете запустить проект, который вы запускали последним, в любое время, используя кнопку «Выполнить» на панели инструментов.
Шаг 4
Вы будете использовать тот же синтаксис всякий раз, когда будете объявлять переменную в Java. Чтобы назначить другое значение переменной позже в программе, вы можете обратиться к ней по имени:
|
1
|
myNum = 3;
|
Это перезаписывает существующее значение. В Java есть много разных типов переменных. Int называется примитивным типом, наряду с несколькими другими числовыми типами, char для символьных значений и логическим значением , в котором хранится либо значение true, либо false. Есть также типы объектов; мы будем исследовать объекты позже. Существенный тип объекта, с которым вы можете ознакомиться, — это String , в котором хранится текстовая строка:
|
1
|
String myName = «Sue»;
|
Значения текстовой строки заключены в кавычки. Вы можете включить их напрямую в некоторых случаях, например:
|
1
|
System.out.println(«number: » + myNum);
|
Добавьте этот код и запустите его, консоль отобразит: «число:», а затем значение переменной.
Шаг 5
Выше мы видели оператор присваивания «=» — вот несколько других распространенных операторов:
|
01
02
03
04
05
06
07
08
09
10
11
12
13
14
|
//add
myNum = 5+6;
//subtract
myNum = 7-3;
//multiply
myNum = 3*2;
//divide
myNum = 10/5;
//remainder
myNum = 10%6;
//increment (add one)
myNum++;
//decrement (subtract one)
myNum—;
|
Операторы могут использоваться как с переменными, так и с жестко заданными числами (как указано выше):
|
1
2
3
|
int myNum = 5;
int myOtherNum = 4;
int total = myNum+myOtherNum;//9
|
Шаг 6
Еще одна структура Java, которая необходима для Android, — это комментарий. Вы можете добавить комментарий двумя способами:
|
1
2
3
4
5
6
|
//this is a single line comment
/* This is a multiline comment
* stretching across lines
* to give more information
*/
|
Очень важно иметь привычку комментировать ваш код во время его написания, для вашей же пользы, а также для всех, кто читает код.
2. Контрольные структуры
Шаг 1
Код, который мы добавили в метод main, выполняется при запуске приложения Java. Когда запускается созданное нами приложение Android, все, что находится в методе onCreate основного Activity, запускается. Каждая строка внутри этих методов выполняется после предыдущей строки, но последовательность выполнения не всегда линейна. В Java задействовано много управляющих структур, поэтому давайте рассмотрим некоторые из наиболее распространенных, начиная с условных.
Условные операторы предполагают проведение тестов для определения последовательности выполнения. Простейшая условная структура в Java — это оператор if :
|
1
2
|
if(myNum>3)
System.out.println(«number is greater than 3»);
|
Этот тест определяет, является ли значение переменной больше трех. Если это так, строка будет записана для вывода. Если нет, то ничего не будет записано, и обработка просто переместится на следующую строку в программе. Мы говорим, что условный тест «возвращает» истинное или ложное значение. Истина и ложь являются логическими значениями. Мы можем добавить else , который выполняется, только если if возвращает false:
|
1
2
3
4
|
if(myNum>3)
System.out.println(«number is greater than 3»);
else
System.out.println(«number is not greater than 3»);
|
Else выполняется, если значение равно трем или меньше. Попробуйте код с другими значениями для целочисленной переменной, чтобы увидеть результаты условных тестов. Мы также можем объединить несколько тестов:
|
1
2
3
4
5
6
7
8
|
if(myNum>10)
System.out.println(«number is greater than 10»);
else if(myNum>7)
System.out.println(«number is greater than 7»);
else if(myNum>3)
System.out.println(«number is greater than 3»);
else
System.out.println(«number is 3 or less»);
|
Каждый тест выполняется, только если все предыдущие тесты в цепочке вернули false. Таким образом, для любого числа выводится только одна строка. Вы можете объединить столько других операторов, сколько вам нужно. Вы также можете использовать операторы if, связанные с одним или несколькими другими блоками if, без финального else .
Мы проверили, что одно число больше другого. Попробуйте следующие варианты:
|
01
02
03
04
05
06
07
08
09
10
|
if(myNum<10)
System.out.println(«number less than 10»);
if(myNum==10)
System.out.println(«number equals 10»);
if(myNum!=10)
System.out.println(«number is not equal to 10»);
if(myNum>=10)
System.out.println(«number either greater than or equal to 10»);
if(myNum<=10)
System.out.println(«number either less than or equal to 10»);
|
Вы можете выполнить аналогичные тесты для других типов переменных, включая строки. Чтобы выполнить несколько тестов одновременно, используйте следующий синтаксис:
|
1
2
|
if(myNum>=10 && myNum<=50)
System.out.println(«number is between 10 and 50»);
|
«&&», известный как оператор «и», означает, что весь оператор вернет true, только если оба теста вернут true. Оператор «или» вернет true, если любой из тестов вернет true:
|
1
2
|
if(myNum<0 || myNum!=-1)
System.out.println(«number is less than 0 or not equal to -1»);
|
Чтобы сгруппировать код в блок, мы можем использовать фигурные скобки — весь код в скобках выполняется, если этот тест возвращает true:
|
1
2
3
4
5
|
if(myNum<10)
{
System.out.println(«number less than 10»);
myNum=10;
}
|
Такие скобки группируют код в циклах, методах и классах.
Шаг 2
Давайте посмотрим на петли сейчас. Следующий цикл for повторяется десять раз, что означает, что его содержимое выполняется десять раз:
|
1
2
3
|
for(int i=0; i<10; i++){
System.out.println(i);
}
|
Первое выражение в схеме for инициализирует целочисленную переменную счетчика в ноль. Второе выражение — это условный тест, проверяющий, что переменная меньше десяти. Если это возвращает true, содержимое цикла выполняется, если не цикл закончится. После выполнения содержимого цикла выполняется третье выражение, увеличивая счетчик.
Цикл while использует немного другой синтаксис. Следующий пример имеет тот же эффект, что и цикл for :
|
1
2
3
4
5
|
int i=0;
while(i<10){
System.out.println(i);
i++;
}
|
Циклы могут содержать несколько строк кода, включая другие циклы.
Шаг 3
Мы уже сталкивались с основным методом и методом Android onCreate . Давайте посмотрим на создание ваших собственных методов. Поместите следующий метод после закрывающей скобки для основного метода:
|
1
2
3
|
public static void doSomething(){
System.out.println(«something»);
}
|
Этот метод определен как открытый, то есть любой класс в проекте может вызывать его обработку. Если он был «приватным», он доступен только внутри класса (это «видимость»). Обычно вам не нужно включать модификатор «static» в ваши первые приложения для Android, поэтому игнорируйте его. «Void» представляет тип возвращаемого значения. В этом случае метод ничего не возвращает. Чтобы выполнить метод, добавьте к нему вызов в вашем основном методе:
|
1
|
doSomething();
|
Запустите ваше приложение, чтобы увидеть эту функцию. Измените метод для возврата значения:
|
1
2
3
|
public static int doSomething(){
return 5;
}
|
Измените вызов метода и запустите снова:
|
1
|
System.out.println(doSomething());
|
Возвращаемое значение выписывается. Методы также могут получать параметры:
|
1
2
3
|
public static int doSomething(int firstNum, int secondNum){
return firstNum*secondNum;
}
|
При вызове метода вы должны передать параметры правильного типа и номера:
|
1
|
System.out.println(doSomething(3, 5));
|
Методы могут разделить обработку приложения на логические порции. Они особенно полезны, если вам нужно выполнять одни и те же задачи более одного раза; вы просто определяете их в методе, а затем вызываете его всякий раз, когда вам это нужно. Если вы измените процесс, вам нужно всего лишь изменить его в коде метода.
3. Классы и объекты
Шаг 1
Мы видели, как можно использовать методы для повторного использования кода и разбиения его на логические разделы. Классы и объекты делают это в большем масштабе. Вы можете разделить задачи в приложении между объектами, причем каждый объект имеет набор обязанностей, определенных его классом. Это похоже на метод, отвечающий за конкретную область функциональности, но объект может иметь несколько методов, а также хранить значения данных.
Представьте, что вы создаете игру — вы можете создать класс, предназначенный для обработки деталей пользователя. Выберите пакет приложения в «src» в Package Explorer. Щелкните правой кнопкой мыши и выберите «Новый», затем «Класс». Введите «GameUser» в качестве имени класса, убедитесь, что на этот раз флажок заглушки основного метода снят, и нажмите «Готово». Затем Eclipse открывает файл класса, который изначально содержит только схему объявления класса:
|
1
2
3
|
public class GameUser {
//class content
}
|
Все, что вы добавляете, находится в этих скобках (если только вы не добавите операторы импорта, которые перечислены выше в этом разделе). Ваши приложения для Android замечают, что в файлах классов имя пакета указано вверху. Это не перечислено здесь, потому что мы использовали пакет по умолчанию.
Шаг 2
Внутри класса добавьте пару переменных:
|
1
2
|
private String playerName;
private int score;
|
Они называются «переменными экземпляра», потому что они определены для каждого экземпляра класса, который мы создаем. Добавьте метод конструктора после них. Это то, что выполняется при создании объекта класса:
|
1
2
3
4
|
public GameUser(String userName, int userScore){
playerName=userName;
score=userScore;
}
|
Конструктор всегда имеет то же имя, что и класс, и может требовать или не требовать параметров. Конструктор обычно должен присваивать значения переменным экземпляра, часто используя параметры.
Шаг 3
Класс также может определять методы. Добавьте следующий типичный набор после конструктора:
|
1
2
3
4
|
public String getName() {return playerName;}
public int getScore() {return score;}
public void setName(String newName) {playerName=newName;}
public void setScore(int newScore) {score=newScore;}
|
Они известны как методы получения и установки, или методы получения и установки, потому что они предоставляют внешний по отношению к классу код с возможностью извлечения и установки значений переменных экземпляра. Взгляните на представление Outline в Eclipse, чтобы увидеть, как оно может помочь в навигации по классу.
Шаг 4
Сохраните ваш новый файл класса. Вернувшись в основной класс, создайте объект нового класса в методе main:
|
1
|
GameUser aUser = new GameUser(«Jim», 0);
|
Мы передаем параметры, перечисленные в конструкторе — ключевое слово «new» заставит конструктор исполниться. Теперь мы можем использовать этот экземпляр класса для доступа к значениям данных в нем, вызывая его методы:
|
1
2
3
|
System.out.println(aUser.getScore());
aUser.setScore(5);
System.out.println(aUser.getScore());
|
Запустите программу, чтобы увидеть, как изменяется значение после вызова открытых методов объекта. Вы можете создать несколько экземпляров объекта, который будет управляться отдельно:
|
1
|
GameUser anotherUser = new GameUser(«Jane», 5);
|
4. Наследование и интерфейсы
Шаг 1
Мы видели, как класс определяет наборы обязанностей, которые вы можете использовать, создавая экземпляры объектов. Это относится не только к классам, которые вы создаете сами, но и к существующим классам Java и Android, которые вы также можете использовать. Помимо создания экземпляров этих платформенных классов, вы можете расширять их, используя наследование. С помощью наследования вы можете создать класс, который наследует функциональность существующего класса, а также обеспечивает собственную обработку. Мы видели пример этого в первом проекте Android, который мы создали, с основным классом Activity.
Откройте класс сейчас. В первой строке объявления класса вы увидите «extends Activity». Это означает, что класс является подклассом класса Android Activity. Использование класса Activity позволяет Android обрабатывать детали представления экрана пользователю с помощью методов, когда экран находится в различных состояниях (создан, приостановлен, уничтожен и т. Д.). Это позволяет вам сосредоточиться на уникальных аспектах приложения, добавляя код в методы, определенные в объявлении класса Android Activity, и дополнительные собственные методы, если это необходимо.
Это шаблон, который вы часто будете использовать в Android, расширяя определенные классы для общих аспектов приложений. Вы можете дополнить их своими собственными классами, где это необходимо.
Шаг 2
Посмотрите еще раз на начальную строку вашего класса деятельности. Помните, что мы добавили «реализует OnClickListener» для обработки нажатий на кнопку в пользовательском интерфейсе. Это называется реализацией интерфейса. Интерфейс похож на класс, который вы наследуете от использования «extends», за исключением того, что объявление Interface просто перечисляет схемы методов. Вы должны предоставить реализацию метода для каждого из них. Поэтому, когда мы реализовали OnClickListener, мы обязали класс предоставить метод onClick , что мы и сделали. Поэтому интерфейс похож на контракт. С наследованием расширяющиеся классы наследуют реализации метода, предоставленные в объявлении класса для их суперкласса (расширяемый класс). Вы можете переопределить эти реализации, если вам нужно.
Вывод
В этом уроке мы описали некоторые основные функции синтаксиса Java, которые вам необходимо понять. Есть больше структур и концепций, с которыми нужно ознакомиться. Если у вас нет опыта работы с Java и вы хотите убедиться, что знаете достаточно, чтобы эффективно разрабатывать для Android, используйте Oracle Java Tutorials . Темы, которые необходимо учить, включают массивы и операторы switch. Позже в этой серии мы рассмотрим некоторые из наиболее распространенных классов Android, которые вы, вероятно, будете использовать. В следующей части мы рассмотрим ресурсы в проекте приложения для Android.