Синтаксис android java: Введение в синтаксис Java для разработки под Android

Введение в синтаксис Java для разработки под Android

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

16.08.2021

— Advertisement —

Java — один из «официальных» языков, поддерживаемых Google для разработки Android, второй — Kotlin. В то время как Google все больше отдает предпочтение последней, Java остается популярной из-за ее широкого использования за пределами Android-разработки. Это востребованный язык, и его изучение может быть чрезвычайно полезным для всех, кто хочет начать карьеру в сфере программирования.

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

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

Давайте посмотрим на грамматику Java и почему некоторые вещи изложены именно так.

---

Основы синтаксиса Java

На данный момент нас не интересует, как работает Java, а скорее ее основные правила написания строки кода.

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

Самое важное правило синтаксиса Java: строки заканчиваются точкой с запятой. Эта пунктуация сообщает Java (и вам), что строка кода закончена и не предназначена для перехода к следующей строке. Вроде как точка! Некоторые языки (например, Kotlin) делают это необязательным, но опускают «;» в Java подчеркнут красный цвет — код не запускается!

Основы синтаксиса Java

Исключение из этого правила — когда вы открываете новые блоки кода. Если вы заканчиваете строку открытой фигурной скобкой ({), вы каким-то образом группируете следующие строки кода. Они будут продолжаться от предыдущей строки до закрытия}.

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

Блоки кода также должны иметь отступ. У вас могут быть блоки внутри блоков внутри блоков (!), А отступы быстро покажут нам логическую группировку нашего кода с первого взгляда. Некоторые другие языки программирования (например, Python) требуют, чтобы эти отступы вообще запускали код, полностью избавившись от фигурных скобок.

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

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

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

ВерблюжийРегистр

Еще одна вещь, о которой следует помнить, — это соглашение об именах для ваших переменных и методов. Когда вы создаете значение, представляющее что-то вроде «Здоровье игрока», вам нужно дать ему имя. Имена переменных не могут включать пробелы, а это значит, что вы рискуете использовать такие фразы, как «здоровье игрока» или более длинные. Если бы у вас была целая страница с таким текстом, его было бы довольно сложно расшифровать довольно быстро! Разборчивый код — всегда лучший код.

ВерблюжийРегистр

Вместо этого мы используем соглашение, известное как «ВерблюжийРегистр», где каждое новое слово начинается с заглавной буквы, чтобы его было легче понять. Таким образом, «Здоровье игрока» становится либо «playerHealth», либо «PlayerHealth». Первый (playerHealth) — это «нижний верблюжий регистр», а второй (PlayerHealth) — «верхний верблюжий регистр».

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

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

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

Очень важно называть вещи логически

Даже основной файл Java в нашей программе, MainActivity, написан на языке ВерблюжийРегистр! В именах файлов также не может быть пробелов. Между тем, в activity_main.xml используется другое соглашение об именах, поскольку файлы в папке ресурсов не могут использовать заглавные буквы (я не устанавливаю правила!). Таким образом, мы используем подчеркивание, чтобы отделить эти слова.

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

Приобретите хорошие привычки сейчас, и вы сэкономите бесчисленное количество часов в будущем.

Читайте также:

• Python или Java: какой язык лучше изучать и в чем различия?
• Как подключаться к веб-API из Android-приложения
• Что такое Python и зачем его изучать?
• Как установить Android Studio и создать свой первый проект

Больше от автора

Похожие посты

Advertisment

Последние посты

Основной синтаксис — Kotlin

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

Вы также можете изучить все основы Kotlin в бесплатном курсе Основы Kotlin от JetBrains Academy.

Определение имени пакета и импорт

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

package my.demo
import java.util.*
// ...

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

См. Пакеты.

Точка входа в программу

В Kotlin точкой входа в программу является функция main.

fun main() {
    println("Hello world!")
}

Другая форма main может принимать массив строк String.

fun main(args: Array<String>) {
    println(args.contentToString())
}

Вывод в стандартный поток

print выводит свой аргумент в стандартный поток вывода.

print("Hello ")
print("world!")

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

println("Hello world!")
println(42)

Функции

Функция принимает два аргумента Int и возвращает Int.

fun sum(a: Int, b: Int): Int {
    return a + b
}

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

fun sum(a: Int, b: Int) = a + b

Функция, не возвращающая никакого значения (void в Java).

fun printSum(a: Int, b: Int): Unit {
    println("сумма $a и $b равна ${a + b}")
}

Тип возвращаемого значения Unit может быть опущен.

fun printSum(a: Int, b: Int) {
    println("сумма $a и $b равна ${a + b}")
}

См. Функции.

Переменные

Неизменяемые (только для чтения) локальные переменные определяются с помощью ключевого слова val. Присвоить им значение можно только один раз.

val a: Int = 1   // Инициализация при объявлении
val b = 1        // Тип `Int` определен автоматически
val c: Int       // Указывать тип обязательно, если переменная не инициализирована сразу
c = 1            // Последующее присвоение

Изменяемые переменные объявляются с помощью ключевого слова var.

var x = 5 // Тип `Int` определен автоматически
x += 1

Вы можете объявлять глобальные переменные.

val PI = 3.14
var x = 0
fun incrementX() { 
    x += 1 
}

См. Свойства и поля.

Создание классов и экземпляров

Для создания класса используйте ключевое слово class.

class Shape

Свойства класса могут быть перечислены при его объявлении или в его теле.

class Rectangle(var height: Double, var length: Double) {
    var perimeter = (height + length) * 2 
}

Конструктор по умолчанию с параметрами, перечисленными при объявлении класса, доступен автоматически.

val rectangle = Rectangle(5.0, 2.0)
println("Периметр равен ${rectangle.perimeter}")

Чтобы объявить наследование между классами используйте двоеточие (:). По умолчанию классы являются финальными, поэтому, чтобы сделать класс наследуемым, используйте open.

open class Shape
class Rectangle(var height: Double, var length: Double): Shape() {
    var perimeter = (height + length) * 2 
}

См. Классы и наследование и Объекты и экземпляры.

Комментарии

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

// Это однострочный комментарий
/* Это блочный комментарий
   из нескольких строк. */

Блочные комментарии в Kotlin могут быть вложенными.

/* Этот комментарий начинается здесь
/* содержит вложенный комментарий */
и заканчивается здесь. */

См. Документация Kotlin кода для информации о документации в комментариях.

Строковые шаблоны

Допустимо использование переменных внутри строк в формате $name или ${name}:

fun main(args: Array<String>) {
  if (args.size == 0) return
  print("Первый аргумент: ${args[0]}")
}

var a = 1
// просто имя переменной в шаблоне:
val s1 = "a равно $a" 
a = 2
// произвольное выражение в шаблоне:
val s2 = "${s1.replace("равно", "было равно")}, но теперь равно $a"
/*
  Результат работы программы:
  a было равно 1, но теперь равно 2
*/

См. Строковые шаблоны.

Условные выражения

fun maxOf(a: Int, b: Int): Int {
    if (a > b) {
        return a
    } else {
        return b
    }
}

В Kotlin if может быть использован как выражение (т. е. if …

else возвращает значение):

fun maxOf(a: Int, b: Int) = if (a > b) a else b

См. Выражение if.

Цикл for

val items = listOf("яблоко", "банан", "киви")
for (item in items) {
    println(item)
}

или

val items = listOf("яблоко", "банан", "киви")
for (index in items.indices) {
    println("${index} фрукт - это ${items[index]}")
}

См. Цикл for.

Цикл while

val items = listOf("яблоко", "банан", "киви")
var index = 0
while (index < items.size) {
    println("${index} фрукт - это ${items[index]}")
    index++
}

См. Цикл while.

Выражение when

fun describe(obj: Any): String =
    when (obj) {
        1          -> "Один"
        "Hello"    -> "Приветствие"
        is Long    -> "Long"
        !is String -> "Не строка"
        else       -> "Unknown"
    }

См.

Выражение when.

Интервалы

Проверка на вхождение числа в интервал с помощью оператора in.

val x = 10
val y = 9
if (x in 1..y+1) {
    println("принадлежит диапазону")
}

Проверка значения на выход за пределы интервала.

val list = listOf("a", "b", "c")
if (-1 !in 0..list.lastIndex) {
    println("-1 не принадлежит диапазону")
}
if (list.size !in list.indices) {
    println("размер списка также выходит за допустимый диапазон индексов списка")
}

Перебор значений в заданном интервале.

for (x in 1..5) {
    print(x)
}

Или по арифметической прогрессии.

for (x in 1..10 step 2) {
    print(x)
}
println()
for (x in 9 downTo 0 step 3) {
    print(x)
}

См. Интервалы.

Коллекции

Итерация по коллекции.

for (item in items) {
    println(item)
}

Проверка, содержит ли коллекция данный объект, с помощью оператора in.

val items = setOf("яблоко", "банан", "киви")
when {
    "апельсин" in items -> println("сочно")
    "apple" in items -> println("яблоко тоже подойдет")
}

Использование лямбда-выражения для фильтрации и модификации коллекции.

val fruits = listOf("банан", "авокадо", "яблоко", "киви")
fruits
    .filter { it.startsWith("а") }
    .sortedBy { it }
    .map { it.uppercase() }
    .forEach { println(it) }

См. Коллекции.

Nullable-значения и проверка на null

Ссылка должна быть явно объявлена как nullable (символ ? в конце имени), когда она может принимать значение null.

Возвращает null, если str не содержит числа.

fun parseInt(str: String): Int? {
  // ...
}

Использование функции, возвращающей null.

fun printProduct(arg1: String, arg2: String) {
    val x = parseInt(arg1)
    val y = parseInt(arg2)
    
    // Использование `x * y` приведет к ошибке, потому что они могут содержать null
    if (x != null && y != null) {
        // x и y автоматически приведены к не-nullable после проверки на null
    print(x * y)
    }
    else {
        println("'$arg1' или '$arg2' не число")
    }
}

или

// . ..
if (x == null) {
    print("Неверный формат числа arg1: '$arg1'")
    return
}
if (y == null) {
    print("Неверный формат числа arg2: '$arg2'")
    return
}
// x и y автоматически приведены к не-nullable после проверки на null
  print(x * y)

См. Null-безопасность.

Проверка типа и автоматическое приведение типов

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

fun getStringLength(obj: Any): Int? {
    if (obj is String) {
        // в этом блоке `obj` автоматически преобразован в `String`
        return obj.length
    }
    // `obj` имеет тип `Any` вне блока проверки типа
    return null
}

или

fun getStringLength(obj: Any): Int? {
    if (obj !is String) return null
    // в этом блоке `obj` автоматически преобразован в `String`
    return obj.length
}

или даже

fun getStringLength(obj: Any): Int? {
    // `obj` автоматически преобразован в `String` справа от оператора `&&`
    if (obj is String && obj. length > 0) {
        return obj.length
    }
    return null
}

См. Классы и Приведение типов.

Синтаксис и элементы объявления с примером в Java

Синтаксис в java относится к набору правил, определяющих, как пишется и интерпретируется программа Java. Синтаксис в основном заимствован из C и C++.

---

СОДЕРЖАНИЕ

• 1 Элементы синтаксиса Java:
• 2 Важность синтаксиса:
• 3 Важные пункты для запоминания:

Элементы синтаксиса Java:

A Java File CAN SOCTED Следующие элементы:

A Java File CAN SOCTED Следующие элементы. :

• Декларация упаковки
• Заявления об импорте
• Декларация типа
• Объявление полей
• Декларация методов
• Декларация конструкторов

Пример общего синтаксиса программы JAVA:

Ниже приведен пример программы, содержащий все вышеперечисленные элементы, которые помогут вам понять основной синтаксис «. java файла»:

 package basicsyntax; //Упаковка

импортировать java.util.HashMap; //Импорт операторов

//Учебный класс
открытый класс MyFirstClass {

Строковое имя = "Рам"; //Поле

// Конструктор в JAVA
общественный MyFirstClass () {
}

//Метод в JAVA
публичная строка getName()
{
вернуть это.имя;
}

//Статический основной метод в JAVA
public static void main(String[] args) {

}
} 

Объяснение всех вышеперечисленных элементов приведено ниже:

1. Объявление пакета:

Первая строка программы показывает объявление пакета. Эта часть, чтобы быть более конкретным:

 базовый синтаксис пакета; 

Объявление пакета состоит из слова package, пробела и имени пакета. Файл .java должен находиться в структуре каталогов, соответствующей имени пакета.

2. Заявления об импорте:

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

 импорт java.util.HashMap; 

3. Объявление типа:

Объявлением типа может быть класс , абстрактный класс , интерфейс , перечисление или аннотация .

Здесь ниже объявленный тип является классом. Объявление типа начинается с открывающей фигурной скобки ({) и заканчивается закрывающей фигурной скобкой (}), как показано в программе:

 открытый класс MyFirstClass {
} 

4. Объявление поля:

Объявление поля заканчивается точкой с запятой (;). Тип (класс/интерфейс/перечисление) может иметь более одного поля. Ниже приведено одно объявление поля:

 Строковое имя = "Ram"; 

5. Объявление конструкторов:

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

 public MyClass() {
} 

6. Объявление методов:

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

 public String getName() {
вернуть это.имя;
} 

7. Основной статический метод:

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

 public static void main(String[] args) {

} 

---

Важность синтаксиса:

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

---

Важные моменты, которые следует помнить:

При работе с Java-программами необходимо помнить о следующих моментах:

• Чувствительность к регистру: –  Java чувствителен к регистру, что означает, что прописные и строчные буквы должны рассматриваться как разные. Например, идентификатор Cat и cat в Java будут иметь разное значение.
• Имена классов: –  Первая буква имени класса должна быть в верхнем регистре. Если имя класса состоит из нескольких слов, то первая буква каждого внутреннего слова должна быть в верхнем регистре. Например: класс MyFirstClass .
• Имена методов: –  Первая буква имени метода должна быть в нижнем регистре. Если имя метода состоит из нескольких слов, то первая буква каждого внутреннего слова должна быть в верхнем регистре. Например:   public void myGetMethod()
• Имя файла программы —  Имя класса и имя файла программы должны совпадать. Вы должны сохранить программный файл, используя имя класса (помните, что Java чувствителен к регистру) и добавить «.java» в конец имени файла при его сохранении. (если имя файла и имя класса не совпадают, ваша программа не скомпилируется)
  Например: предположим, что «MyFirstProgram» — это имя класса. Затем файл следует сохранить как ‘MyFirstProgram.java’
.
• public static void main(String args[]) – Это обязательная часть каждой Java-программы, когда обработка Java-программы начинается с метода main().

Введение в синтаксис Java для разработки под Android

Java — один из «официальных» языков, которые Google поддерживает для разработки под Android, второй — Kotlin. В то время как Google все больше отдает предпочтение последнему, Java остается популярной из-за ее широкого использования вне Android-разработки. Это востребованный язык, и его изучение может быть чрезвычайно полезным для всех, кто хочет начать карьеру в сфере разработки.

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

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

Давайте посмотрим на грамматику Java и на то, почему некоторые вещи расположены именно так, как они есть.

Основы синтаксиса Java

На данный момент нас интересует не столько то, как работает Java, сколько основные правила написания строки кода.

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

Самое важное правило синтаксиса Java: строки заканчиваются точкой с запятой. Этот знак препинания сообщает Java (и вам), что строка кода закончилась и не предназначена для перехода к следующей строке. Что-то вроде полной остановки! Некоторые языки (например, Kotlin) делают это необязательным, но опускают «;» в Java будет подчеркнуто красным — код не запустится!

Исключением из этого правила является открытие новых блоков кода. Если вы заканчиваете строку открытой фигурной скобкой ({), вы каким-то образом группируете следующие строки кода. Они будут следовать из предыдущей строки до закрывающего }.

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

Блоки кода также должны иметь отступ. У вас могут быть блоки внутри блоков внутри блоков (!), и отступы быстро покажут нам логическую группировку нашего кода с первого взгляда. Некоторые другие языки программирования (например, Python) требуют, чтобы эти отступы вообще выполняли код, полностью избавляясь от фигурных скобок.

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

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

Хотя поначалу это может выглядеть довольно чуждо, у всего есть причина

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

camelCase

Еще одна вещь, о которой следует помнить, — это соглашение об именах переменных и методов. Когда вы создаете значение, представляющее что-то вроде «Здоровье игрока», вам нужно дать ему имя. Имена переменных не могут содержать пробелы, а это означает, что вы рискуете получить повторяющиеся фразы, такие как «здоровье игрока» или более длинные. Если бы у вас была целая страница такого текста, расшифровать его было бы довольно сложно! Разборчивый код всегда лучший код.

Вместо этого мы используем соглашение, известное как «верблюжий регистр», когда каждое новое слово начинается с заглавной буквы, чтобы его было легче понять. Таким образом, «Player Health» становится либо «playerHealth», либо «PlayerHealth». Первый (playerHealth) — «нижний верблюжий регистр», а второй (PlayerHealth) — «верхний верблюжий регистр».

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

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

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

Даже главный Java-файл в нашей программе, MainActivity, написан в camelCase! Также нельзя использовать пробелы в именах файлов.