Синтаксис ява: Базовый синтаксис Java для начинающих

11.06.2019, Вт, 09:21, Мск , Текст: Валерия Шмырова

Язык Python, который сейчас находится на третьем месте в рейтинге TIOBE, демонстрирует быстрый рост индекса. Составители рейтинга полагают, что через три-четыре года он возглавит рейтинг, заменив C и Java. Основной причиной роста является простота использования языка для новичков.

Python заменит C и Java

Через три-четыре года Python заменит C и Java, став самым популярным языком программирования. К такому выводу пришли составители индекса TIOBE, который оценивает популярность различных языков. Индекс рассчитывается в ходе анализа результатов поисковых запросов, которые содержат название языка, на таких порталах как Google, Blogger, Wikipedia, YouTube, Baidu, Yahoo!, Bing, Amazon и т. д.

В настоящий момент Python занимает третье место в рейтинге TIOBE с показателем 8,5%. Аналитики отмечают, что это самый высокий балл Python за все время его присутствия в рейтинге. Результат показал годовой рост на 2,77%. Сейчас Python уступает только Java и C, показатели которых равны 15% и 13,3% соответственно.

В первую десятку рейтинга также входят C++, Visual Basic .NET, C#, JavaScript, PHP, SQL и Assembly.

Напомним, Python был создан нидерландским разработчиком Гвидо ван Россум (Guido van Rossum) в 1989 г. Ван Россум официально занимает в проекте пост «великодушного пожизненного диктатора» (BDFL). Python сейчас является одним из самых широко используемых в мире языков программирования, идеальным для новичков и в тоже время нашедшим применение в масштабных проектах, в том числе YouTube, Instagram и Dropbox. Сам Гвидо как раз и работает в Dropbox, после того как в 2012 г. ушел из Google.

Другие признаки роста

Еще одним показателем популярности Python является то, что в маркетплейсе для редактора исходного кода Visual Studio Code, разработанного Microsoft, приложение Python для редактора является самым популярным — сейчас количество его установок превышает 9 млн, хотя еще в апреле их было 8 млн.

Python поднимается вверх в рейтинге TIOBE

В настоящий момент в популярной системе вопросов и ответов о программировании Stack Overflow задается больше вопросов о Python, чем о Java, который лидировал до этого. В 2018 г. Stack Overflow поставил Python на седьмое место среди самых популярных языков программирования, написания скриптов и разметки, причем в этом списке Python опередил языки C#, Ruby и PHP.

Исследование, проведенное среди 12 млн ИТ-специалистов компанией Skillsoft, показало, что общее время тренировки Python разработчиками выросло в 2018 г. на 20% по сравнению с предыдущим годом и составила 200 тыс. часов. Профильный ресурс CodingDojo поставил владение Python на второе место в списке самых востребованных работодателями навыков разработчика.

Причины роста

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

«Чтобы полностью понять и запустить простую программу, такую как Hello world на Java, вам необходимо знать классы, статические методы и пакеты. В C это немного проще, но тогда вы столкнетесь с явным управлением памятью. В Python это всего лишь одна строка», — поясняют аналитики.

Важным фактором роста популярности Python стало то, что компании типа Netflix используют этот язык везде, где только возможно — для создания алгоритмов рекомендаций, управление сетями распространения контента и автоматизации функций безопасности. Сам по себе Python становится более гибким и полезным во многом благодаря популярным библиотекам, таким как TensorFlow и Numpy.

Строки. Часть 8 – форматирование строк (теория).

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

Число x можно вывести на консоль с помощью выражения System.out.println(x). В результате на экране отобразится число с максимальным количеством значащих цифр, допустимых для данного типа. Например, в результате выполнения приведенного ниже фрагмента кода на экран будет выведено число 3333.3333333333335.

В ряде случаев это создает проблемы. Так, например, если вы хотите вывести на экран сумму в долларах и центах, большое количество цифр затруднит восприятие.

Форматирование строк делает их восприятие более приятным и понятным. Посмотрим какой вывод генерирует данная программа:

Как видите такой вывод более приятен и понятен. Например, первый оператор printf форматирует число x таким образом (%.2f), что длина общего поля равна размеру всего числа, а десятичная часть занимает от этого только два числа (поля).

Второй оператор printf уже форматирует значение x в виде числа, размер поля которого составляет 8 цифр, а дробная часть равна двум цифрам (%8.2f). Можете посчитать и убедиться. Кроме того обратите внимание что между символом равно (=) и числом появился пробел, поскольку для всего поля числа отведено 8 символов и все не занятые поля заполняются пробелами и происходит выравнивание по правому краю. Следующий printf уже отвел под поле числа 16 символов (%16.2f), что тоже видно на выводе программы. И последним я продемонстрировал работу метода format() класса String. Они имеют абсолютно одинаковый синтаксис, так как их функционал основан на классе Formatter.

Теперь будем разбираться более подробно с синтаксисом форматирования строк.

В методах printf() и format() можно задавать произвольное количество параметров. Пример вызова с несколькими параметрами приведен ниже.

System.out.printf(«%s, в следующем году вам будет %d», name, age);

В данном случае значение переменной (параметра) name будет подставлено вместо спецификатора формата %s, а значение переменной (параметра) age – вместо спецификатора формата %d.

Каждый спецификатор формата, начинающийся с символа %, заменяется соответствующим параметром. Символ преобразования, которым завершается спецификатор формата, задает тип форматируемого значения: f — число с плавающей точкой; s — строка; d — десятичное число; и т.п. Символы преобразования описаны в таблице ниже:

На заметку! Преобразование s можно использовать для форматирования любого объекта. Если этот объект реализует интерфейс Formattable, вызывается метод formatTo(). В противном случае для преобразования объекта в строку применяется метод toString().

Для даты и времени параметр х может быть представлен следующими символами преобразования:

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

Например, запятая, используемая в качестве флага, формирует разделитель групп, который зависит от локали (формата) установленной в вашей ОС. Так, в результате выполнения на Windwos 8.1 в русской локали, приведенного ниже оператора на экран будет выведена строка 3 333,33.

System.out.printf(«%,.2f», 10000.0 / 3.0);

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

На заметку! Ряд правил форматирования зависит от специфических условий конкретной страны или региона.

В одном спецификаторе формата можно использовать несколько флагов, например последовательность символов «%, (.2f» указывает на то, что при выводе будут использованы разделители групп, а отрицательные числа будут помещены в скобки). Например строка:

System.out.printf(«%, (.2f», -10000.0 / 3.0);

Сгенерирует вот такой вывод: (3 333,33)

Для создания форматированной строки без вывода ее можно использовать статический метод String.format(). Например:

String message = String.format(«%s, в следующем году вам будет %d», name, age);

В строке, определяющей формат, может задаваться индекс форматируемого параметра. Индекс должен следовать непосредственно за символом % и завершаться знаком $. Пример использования индекса приведен ниже.

System.out.printf(«%1$s %2$tB %2$te, %2$tY», «Дата:», new Date());

Данный код сформирует такой вывод: Дата: июня 11, 2015

Внимание! Индексы начинаются с единицы.

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

System.out.printf(«%s %tB %<te, %<tY», «Дата:», new Date());

Чтобы все стало чуть более понятно, то, кратко, общий синтаксис можно описать так:

%[аргумент_индекс][флаги][ширина][.точность]символ_преобразования

Спецификатор ширина управляет минимальным размером поля, при необходимости пустые поля заполняются пробелами. По умолчанию данные выравниваются по правому краю, но тип выравнивания можно переопределить, включив символ – в секцию флаги.
В отличие от ширины поле точность задает минимальное значение. И если ширина относится ко всем типам преобразований данных и работает одинаково для всех типов, то точность имеет разный смысл для разных типов. Для объектов String точность задет максимальное количество выводимых символов. Для вещественных чисел точность задает количество выводимых знаков после запятой (шесть по умолчанию), с округлением или добавлением завершающих нулей в случае необходимости. Так как целые числа не имеют дробной части, точность на них не распространяется, и при попытке применения этого спецификатора с целым числом будет вызвано исключение.

В заключение теории приведу диаграмму которая показывает синтаксис спецификатора формата:

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

Глава 18. Синтаксис

В этой главе представлена ​​грамматика для языка программирования Java.

Грамматика представлена ​​по частям в предыдущих главах (§2.3) намного лучше для описания, но он не очень подходит в качестве основы для парсера. В грамматика, представленная в этой главе, является основой для справки выполнение. Обратите внимание, что это не грамматика LL (1), хотя во многих случаях это сводит к минимуму необходимость смотреть вперед.

В приведенной ниже грамматике используется следующие соглашения в стиле BNF:

• [x] обозначает ноль или одно вхождение x .

• {x} обозначает ноль или более случаев x .

• (x | y) означает один из x или y .

Идентификатор:
IDENTIFIER

QualifiedIdentifier:
Идентификатор {. Идентификатор}

QualifiedIdentifierList:
QualifiedIdentifier {, QualifiedIdentifier}

CompilationUnit:
[[Аннотации] пакет QualifiedIdentifier ; ]
{ImportDeclaration} {TypeDeclaration}

ImportDeclaration:
import [ static ] Идентификатор {. Идентификатор} [. , * ] ;

Декларация типа:
ClassOrInterfaceDeclaration
;

ClassOrInterfaceDeclaration:
{Modifier} (ClassDeclaration | InterfaceDeclaration)

ClassDeclaration:
NormalClassDeclaration
EnumDeclaration

InterfaceDeclaration:
NormalInterfaceDeclaration
Declaration Type
реализует TypeList] ClassBody

EnumDeclaration:
enum Identifier [ реализует TypeList] EnumBody

NormalInterfaceDeclaration:
interface Identifier [TypeParameters] [TypeParameters] [

0 расширяет

Тип:
BasicType { [] }
ReferenceType { [] }

BasicType:
byte
short
char
int
long
float
двойной
логический

ReferenceType:
Идентификатор [TypeArguments] {. Идентификатор [TypeArguments]}

TypeArguments:
< TypeArgument {, TypeArgument} >

TypeArgument:
ReferenceType
? [( расширяет | super ) ReferenceType]

NonWildcardTypeArguments:
< TypeList >

TypeList:
ReferenceType {, ReferenceType}

TypeArgumentsOrDiamond:
<>
ArgumentsOrDiamond:
<>
ArgumentsTypeArguments
< TypeParameter {, TypeParameter} >

TypeParameter:
Identifier [ extends Bound]

Bound:
ReferenceType { & ReferenceType}



Модификатор:
Annotation
public
protected
private
static
abstract
final
native
synchronized
transient
volatile
strictfp

Annotations:
Annotation {Annotation}

Annotation:
@ QualifiedIdentifier [ ( [AnnotationElement] ) ]

AnnotationElement:
ElementValuePairs
ElementValuePair
ElementPairalue

Выписка:
Блок
;
Идентификатор : Заявление
Заявление ;
if Заявление ParExpression [ else Заявление]
assert Expression [: Expression] ;
коммутатор ParExpression { SwitchBlockStatementGroups }
при этом Заявление ParExpression
do Заявление при ParExpression ;
для ( ForControl ) Заявление
break [Идентификатор] ;
продолжить [Идентификатор] ;
возврат [Выражение] ;
бросить Выражение ;
синхронизировано Блок ParExpression
try Block (Улавливает | [Улавливает] Наконец)
try Блок спецификации ресурса [Улавливает] [И наконец]

StatementExpression:
Выражение

Уловы:
CatchClause {CatchClause}

CatchClause:
catch ( {VariableModifier} CatchType Identifier ) Блок

CatchType:
QualifiedIdentifier { | QualifiedIdentifier}

Наконец:
наконец Блок

ResourceSpecification:
( Resources [; ] )

Resources:
Resource {; Resource}

Resource:
{VariableModifier} ReferenceType VariableDeclaratorId = Выражение

SwitchBlockStatementGroups:
{SwitchBlockStatementGroup}

SwitchBlockStatementGroup:
SwitchLabels BlockStatements

SwitchLabels:
SwitchLabel {SwitchLabel}

SwitchLabel: по умолчанию
case Expression

EnumConstantName:
Идентификатор

ForControl:
ForVarControl
ForInit ; [выражение] ; [ForUpdate]

ForVarControl:
{VariableModifier} Тип VariableDeclaratorId ForVarControlRest

ForVarControlRest:
ForVariableDeclaratorsRest ; [выражение] ; [ForUpdate]
: Выражение

ForVariableDeclaratorsRest:
[ = VariableInitializer] {, VariableDeclarator}

ForInit:
ForUpdate:
Выражение выражения

Выражение:
Выражение1 [AssignmentOperator Expression1]

Оператор присвоения:
=
+ =
- =
* =
/ =
& =
| =
^ =
% =
<< =
>> =
>>> =

Expression1:
Expression2 [Expression1Rest]

Expression1Rest:
? Expression : Expression1

Expression2:
Expression3 [Expression2Rest]

Expression2Rest:
{InfixOp Expression3}
instanceof Type

InfixOp:
||
&&
|
^
и
==
! =
<
>
<=
> =
<<
>>
> >>
+
-
*
/
%

Expression3:
PrefixOp Expression3
( (Expression | Type) ) Expression3
Primary {Selector} {PostfixOp }

PrefixOp:
++
-
!
~
+
-

PostfixOp:
++
-

Primary:
Literal
ParExpression
this [Arguments]
super SuperSuffix
new Creator
NonWildcardTypeArguments (ExplicitGenericInvocationSuffix | this Arguments)
Identifier {. Идентификатор} [IdentifierSuffix]
BasicType { [] } . класс
недействителен . class

Literal:
IntegerLiteral
FloatingPointLiteral
CharacterLiteral
StringLiteral
BooleanLiteral
NullLiteral

ParExpression:
( Выражение )

Аргументы:
)

SuperSuffix:
Аргументы
. Идентификатор [аргументы]

ExplicitGenericInvocationSuffix:
super SuperSuffix
Identifier Arguments

Создатель:
NonWildcardTypeArguments CreatedName ClassCreatorRest
CreatedName (ClassCreatorRest | ArrayCreatorRest)

CreatedName:
Идентификатор [TypeArgumentsOrDiamond] {. Идентификатор [TypeArgumentsOrDiamond]}

ClassCreatorRest:
Аргументы [ClassBody]

ArrayCreatorRest:
[ (] { [] } ArrayInitializer | Expression ] { [] Expression ] [] [] })

Идентификатор Суффикс:
[ ({ [] } . класс | Expression) ]
Аргументы
. ( класс | ExplicitGenericInvocation | это | супер Аргументы |
новых [NonWildcardTypeArguments] InnerCreator)

ExplicitGenericInvocation:
NonWildcardTypeArguments ExplicitGenericInvocationSuffix

InnerCreator:
Идентификатор [NonWildcardTypeArgumentsOrDiamond] ClassCreatorRest

Selector:
. Идентификатор [Аргументы]
. ExplicitGenericInvocation
. это
. супер SuperSuffix
. новый [NonWildcardTypeArguments] InnerCreator
[ Expression ]



EnumBody:
{ [EnumConstants] [, ] [EnumBodyDeclarations] }

EnumConstants:
EnumConstant
EnumConstants , EnumConstant

EnumConstants] [Идентификаторы EnumBody] [

] [Идентификаторы EnumBody] [Объяснения]
[EnumConstantings]

EnumBodyDeclarations:
; {ClassBodyDeclaration}

AnnotationTypeBody:
{[AnnotationTypeElementDeclarations] }

AnnotationTypeElementDeclarations:

AnnotationTypeElementDeclaration AnnotationTypeElementDeclarations AnnotationTypeElementDeclaration

AnnotationTypeElementDeclaration:
{} Модификатор AnnotationTypeElementRest

AnnotationTypeElementRest:
Идентификатор AnnotationMethodOrConstantRest ;
ClassDeclaration
InterfaceDeclaration
EnumDeclaration
AnnotationTypeDeclaration

AnnotationMethodOrConstantRest:
AnnotationMethodRest
ConstantDeclaratorsRest

Образец: Грамматика языка Java

Источник: Спецификация языка Java (1.0Alpha3) [HEADING75 в javaspec_11] Я расширяю его, чтобы включить небольшие изменения, сделанные в Java2.0.

Для получения более общей информации следуйте этим указателям: [java.html] [java.glossary.html] Для получения информации о семантике и предопределенных классах следуйте этим указателям: [java.semantics.html] , [java.html] , [java.classes.html]

Примечание

Обозначение

 import mystuff.Fun; 

 посылка mystuff 

 ClockWatcher timer = новый ClockWatcher (clock1) {int count; void tick () {count ++;}}; 

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

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

Файл Java может содержать следующие элементы:

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

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

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

 пакет basicsyntax; //Упаковка

import java.util.HashMap; // Импорт заявлений

//Класс
public class MyFirstClass {

Строка name = "Ram"; //Поле

// Конструктор в JAVA
public MyFirstClass () {
}

// Метод в JAVA
общедоступная строка getName ()
{
вернуть this.name;
}

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

}
} 

Пояснения ко всем вышеперечисленным элементам приведены ниже:

1.Декларация посылки:

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

 пакет basicsyntax; 

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

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

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

 import java.util.HashMap; 

3. Декларация типа:

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

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

 public class MyFirstClass {
} 

4.Полевая декларация:

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

 Строка name = "Ram"; 

5. Декларация строителей:

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

 public MyClass () {
} 

6. Заявление о методах:

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

 public String getName () {
вернуть this.name;
} 

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, обработка которой начинается с метода main ().

Краткий справочник по синтаксису Java

В этом документе слова, заключенные в угловые скобки (например, < это >) - это вещи, которые следует заменить на то, что вы хочу, чтобы код делал.

Типы

Основные типы: char, int и двойной.

Идентификаторы

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

Комментарии

  // < stuffExplainingYourProgram >
 

Функции

  public static < returnValueType > < functionName > (< parameterList >) {
    < переменная Декларация >

    < statementToDo >
  }
 

Объявления переменных базового типа

  < имя_типа > < имя_переменной >;
 

Объявления переменных массива

  < имя_типа > [] < имя_переменной > = новое < имя_типа > [< arrayLengthExpression >];
 

заявление о возврате

  return < returnValueExpression >;
 

Заявление о переуступке

  < variableToBeChanged > = < valueToGiveItExpression >;
 

if операторы

  if (< условие >) {
    < statementToDoIfConditionTrue >
  }
 

  if (< условие >) {
    < statementToDoIfConditionTrue >
  } еще {
    < statementToDoIfConditionFalse >
  }
 

  if (< условие >) {
    < statementToDoIfConditionTrue >
  } else if (< otherCondition >) {
    < statementToDoIfOtherConditionTrue >
  } еще {
    < statementToDoIfNoneAreTrue >
  }
 

, а выписка

  while (< условие >) {
    < statementToDoWhileConditionTrue >
  }
 

для выписки

  for (< initializeAssignment >; < condition >; < updateAssignment >) {
    < statementToDoWhileConditionTrue >
  }
 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

camelCase

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

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

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

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

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

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

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

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

Связанные

Синтаксис Java | Автоматизация в тестировании

Главная страница курса | Что такое синтаксис? | Примеры кода

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

Вот код и комментарии, объясняющие базовый синтаксис Java.

  // Это комментарий кода

// Вот так мы импортируем другую библиотеку или класс в наш класс.
// Итак, в этом случае мы хотим использовать тестовую библиотеку JUnit.
// В данном случае мне нужен класс Test.
import org.junit.Test;

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

// Затем открываем фигурные скобки. Это означает, что все, что находится внутри этой фигурной скобки, является частью синтаксиса класса.
{
    // Здесь у нас есть переменная. Но синтаксис следующий
    // Мы начинаем с модификатора доступа, за которым следует Тип, а затем имя нашей переменной.
    // Затем мы должны закончить строку. Это делается для того, чтобы компилятор знал, где заканчивается строка, в Java мы делаем это через точку с запятой
    общедоступная строка testName;

    // Здесь мы объявляем метод. Снова мы начинаем с модификатора, за которым следуют Тип и имя.// Отличие в скобках (). Они сообщают компилятору, что следующий код является методом
    public void FakeTest ()
    // Затем мы открываем фигурные скобки, как мы это делали с классом, чтобы сообщить компилятору, что код в этих фигурных скобках принадлежит методу
    {
        // Здесь мы делаем кое-что классное

    // Затем мы закрываем скобку, чтобы сказать, что это конец нашего метода
    }

// Затем мы закрываем нашу самую первую скобку, чтобы сообщить компилятору, что это конец нашего класса
}

  

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

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

Следующий урок

Java Syntax Puzzlers - DZone Java

Примерно 12 лет назад я начал вносить свой вклад в экосистему Eclipse, выполняя различные функции.Одним из самых интересных событий на тот момент была работа над инструментами разработчика и обработкой крайних случаев, чтобы другим не приходилось бороться. Хотя я тем временем ушел с поста коммиттера Eclipse, я все еще привязан к работе над инструментами повышения производительности в настоящее время в качестве члена Gradle Build Tool.

Во время работы над Eclipse я с любовью вспоминаю, как работал над различными частями Java Tooling (JDT), работая над рефакторингом и быстрыми исправлениями. И неудивительно, что работа над элементами, интенсивно использующими язык, оказалась с теми же проблемами, что и другие нетривиальные алгоритмы - переход от «это будет легко» к «почему я встаю в 3 часа ночи и читаю спецификацию языка Java?»

Открытие отчета об ошибке с фрагментом для воспроизведения: 10 мин.Работа над патчем: 2ч. Спросить, сможете ли вы закончить патч 11 лет спустя: бесценно. Я скучаю по работе над #eclipse #jdt, хотя https://t.co/vpLD73zOlC

- Бенджамин Маскалла (@bmuskalla) 27 марта 2019 г.

Работа над инструментами для конкретного языка открывает вам все виды крайних случаев и тонких деталей, которые может предложить язык. Некоторые из них хорошо известны и обычно считаются «непрофессиональными» (привет goto ). О других вообще ничего не известно. И, при всем уважении, мне очень нравится обнаруживать крайние случаи синтаксиса языка - много раз, чтобы сбить с толку моих коллег, которые думают, что знают синтаксис языка Java.И, учитывая, что я люблю хорошие головоломки (особенно головоломки Java), давайте попробуем головоломку, но используя только синтаксис Java, без какого-либо поведения во время выполнения.

Использование Java для фишинга

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

В качестве закуски в следующем (удаленном) сеансе сопряжения просто вставьте «Греческий вопросительный знак» ( U + 037E ) в код и наблюдайте, как ваш коллега пытается выяснить, что не так с этой простой точкой с запятой.Этот метод чаще всего используется в фишинговых письмах, чтобы URL-адрес выглядел как настоящий, но на самом деле указывает на совершенно другой домен.

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

Угадайте, что печатает следующая программа?

Да, в контексте сообщения вы правильно догадались, что он печатает «1 равно 2». Только как? Как можно обмануть Java, заставив думать 1 == 2, даже с помощью магии Unicode? ВНУТРИ КОММЕНТАРИИ.Есть догадки? Фактически это не меняет выражения. При этом были повреждены следующие символы Unicode:

• - символ новой строки \ n
• = - закрывающая фигурная скобка }
• > - открывающаяся фигурная скоба {

Итак, на самом деле мы смотрим на следующий код:

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

Блоки блоков

Давайте перейдем к Спецификации языка Java и посмотрим, какие интересные фрагменты синтаксиса мы можем там найти.

Рассматривая возможности, которые у нас есть для реализации методов, Java определяет тело метода таким образом, чтобы оно содержало Block элементов:

При внимательном рассмотрении определения «Блок» мы узнаем, что они могут содержать операторы (пока все хорошо), но также… ClassDeclaration s.Теперь становится интересно. Посмотрим, насколько глубока кроличья нора.

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

То и это

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

Итак, мы создаем новый экземпляр KeywordParameter и вызываем для него метод callMe , передавая параметр int .Но подождите, у метода есть два параметра. И один даже назван по ключевому слову. Это даже не должно компилироваться, верно? Это действительно так. Глядя на объявления методов JLS 8.4, мы можем найти определение для объявлений методов.

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

Так называемый «параметр приемника» - это «необязательное синтаксическое устройство», представляющее объект, для которого он вызывается (так что это действительно то же самое, что вы ожидаете от на ).