Java Базовый синтаксис

💖 Нравится? Поделись с друзьями ссылкой

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

Объект - объекты имеют состояние и поведение. Например: собака может иметь состояние - цвет, имя, а также и поведение - кивать, бежать, лаить, кушать. Объект является экземпляром класса.

Класс - может быть определен как шаблон, который описывает поведение объекта.

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

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

Первая программа и знакомство с синтаксисом языка

Давайте рассмотрим простой код, в результате которого будут выведены на экран слова «Привет мир!», а за одно и синтаксис Java.

Public class MyFirstJavaProgram { public static void main(String args) { /* Это первая моя java-программа. В результате выполнения на экран будет выведено "Привет мир!" */ System.out.println("Привет мир!"); // Вывод сообщения на экран } }

  • Откройте блокнот и добавьте код, указанный выше.
  • Сохраните файл как «MyFirstJavaProgram.java». Ниже мы рассмотрим синтаксис Java и узнаем почему именно под таким именем.
  • Откройте окно командной строки и перейдите в каталог, где был сохранен файл. Предположим, что это «C:\».
  • Введите «Javac MyFirstJavaProgram.java» и нажмите ввод, чтобы скомпилировать код. Если нет ошибки в коде, командная строка приведет Вас к следующей строке: (Assumption: The path variable is set).
  • Теперь введите «java MyFirstJavaProgram» для запуска программы.
  • Теперь Вы увидите «Привет Мир!», напечатанный в окне.
C:> javac MyFirstJavaProgram.java C:> java MyFirstJavaProgram Привет мир!

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

Очень важно знать и помнить следующие моменты в синтаксисе:

  • Чувствительность к регистру - Java чувствителен к регистру, то есть идентификатор Hello и hello имеют разный смысл.
  • Название классов - для всех первая буква должна быть в верхнем регистре.
  • Если несколько слов используются, чтобы сформировать название класса, первая буква каждого внутреннего слова должна быть в верхнем регистре, например, «MyJavaClass».
  • Название методов - в синтаксисе Java все имена методов должны начинаться с буквы нижнего регистра.
  • Если несколько слов используются, чтобы сформировать имя метода, то первая буква каждого внутреннего слова должна быть в верхнем регистре, например, «public void myMethodName()».
  • Название файла программы - наименование файла программы должно точно совпадать с именем класса.
  • При сохранении файла, Вы должны сохранить его, используя имя класса (помните о чувствительности к регистру) и добавить «.java» в конце имени (если имена не совпадают, Ваша программа не будет компилироваться), например, «MyJavaProgram» - это название класса, тогда файл должен быть сохранен как «MyJavaProgram.java».
  • public static void main(String args) - обработка программы начинается с метода Main(), который является обязательной частью каждой программы.

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

Идентификаторы - имена, используемые для классов, переменных и методов. Все компоненты Java требуют имена.

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

  • Каждый идентификатор должен начинаться с «A» до «Z» или «a» до «z», «$» или «_».
  • После первого символа может иметь любую комбинацию символов.
  • Ключевое слово не может быть использовано в качестве идентификатора.
  • Самое главное - идентификатор в Java чувствителен к регистру.
  • Пример правильного написания: age, $salary, _value, __1_value.
  • Пример неправильного написания: 123abc, -salary.

Перечисления

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

С использованием перечисления в Java можно уменьшить количество ошибок в коде.

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

Пример кода перечисления в Java

class FreshJuice { enum FreshJuiceSize{ SMALL, MEDIUM, LARGE } FreshJuiceSize size; } public class FreshJuiceTest { public static void main(String args){ FreshJuice juice = new FreshJuice(); juice.size = FreshJuice.FreshJuiceSize.MEDIUM; System.out.println("Размер: " + juice.size); } }

Полученный результат выше приведенного примера:

Размер: MEDIUM

Примечание: в Java перечисления могут быть объявлены как самостоятельно, так и внутри класса. Методы, переменные, конструкторы могут быть определены также внутри перечисления.

Типы переменных

  • Локальные переменные.
  • Переменные класса (статические).
  • Переменные экземпляра (динамические).

Модификаторы

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

  • С доступом: default, public, protected, private.
  • Без доступа: final, abstract, strictfp.

Более подробно рассмотрим модификаторы класса, модификаторы методов и другие в следующем разделе.

Массив

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

Страницы JSP имеют комбинированный синтаксис: объединение стандартного синтаксиса, соответствующего спецификации HTML, и синтаксиса JSP, определенного спецификацией Java Server Pages. Синтаксис JSP определяет правила записи страниц JSP, состоящих из стандартных тегов HTML и тегов JSP. Страницы JSP, кроме HTML-тегов, содержат теги JSP следующих категорий:

Директивы JSP

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

Директивы всегда помещаются в начале JSP-страницы до всех остальных тегов, чтобы parser (анализатор) JSP при разборе текста в самом начале выделил глобальные инструкции. Таким, образом, JSP Engine (среда исполнения JSP), анализируя код, создает из JSP сервлет. Директивы представляют собой сообщения контейнеру JSP. Синтаксис директив JSP выглядит следующим образом:

<%@ директива имяАтрибута="значение" %> Синтаксис задания директив на XML: Директива может иметь несколько атрибутов. В этом случае директива может быть повторена для каждого из атрибутов. В то же время пары "имяАтрибута=значение" могут располагаться под одной директивой с пробелом в качестве разделителя. Существует три типа директив:

  • page (страница)
  • taglib (библиотека тегов)
  • include (включить)

Директива page

Директива page определяет свойства страницы JSP, которые воздействуют на транслятор. Порядок следования атрибутов в директиве page не имеет значения. Нарушение синтаксиса или наличие нераспознанных атрибутов приводит к ошибке трансляции. Примером директивы page может служить следующий код: <%@ page buffer="none" isThreadSafe="yes" errorPage="/error.jsp" %> Эта директива объявляет, что данная страница JSP не использует буферизацию, что возможно одновременное обращение к данной странице JSP многих пользователей, и что поддерживается страница ошибок с именем error.jsp .
Директива page может содержать информацию о странице: <%@ page info = "JSP Sample 1" %> Список возможных атрибутов директивы page представлен в таблице.
Наименование атрибута Значение Описание
language Строка Определяет язык, используемый в скриптлетах файла JSP, выражениях или любых включаемых файлах, в том числе, в теле оттранслированного кода. По умолчанию принимается значение "java"
extends Строка Задает суперкласс для генерируемого сервлета. Этот атрибут следует использовать с большой осторожностью, поскольку возможно что сервер уже использует какой-нибудь суперкласс
import Строка Определение импортируемых пакетов., например:
<%@ page import="java.util.* %>
Session true или false Значение true (принимается по умолчанию) свидетельствует о том, что заранее определенная переменная session (тип HttpSession) должна быть привязана к существующей сессии, если таковая имеется, в противном случае создается новая сессия, к которой осуществляется привязка. Значение false определяет что сессии не будут использоваться, и попытки обращения к переменной session приведут к возникновению ошибки при трансляции JSP страницы в сервлет
Buffer none или размер буфера в кБ. Задает размер буфера для JspWriter out. Значение принимаемое по умолчанию зависит от настроек сервера, и не должно превышать 8 кБ. Если значение равно none вывод происходит непосредственно в объект
autoFlush true или false Определяет, должен ли буфер освобождаться автоматически, когда он переполнен или произошла ошибка. По умолчанию значение true
isThreadSafe true или false Значение true (принимается по умолчанию) задает нормальный режим выполнения сервлета, когда множественные запросы обрабатываются одновременно с использованием одного экземпляра сервлета, исходя из соображения, что автор синхронизировал доступ к переменным этого экземпляра. Значение false ("ложь") сигнализирует о том, что сервлет должен наследовать SingleThreadModel (однопоточную модель), при которой последовательные или одновременные запросы обрабатываются отдельными экземплярами сервлета
info Строка Определяет строку информации о странице JSP, которая будет доступна с помощью метода Servlet.getServletInfo ()
errorPage Строка Значение атрибута представляет собой URL страницу, которая должна выводиться в случае возможных ошибок, вызывающих исключения
isErrorPage true или false Сигнализирует о том, может ли эта страница использоваться для обработки ошибок для других JSP страниц. По умолчанию принимается значение false
contentType Строка Определяет кодировку для страницы JSP и ответа, а также MIME-тип ответа JSP. Значение по умолчанию типа содержания - text/html , кодировки - ISO-8859-1. Например:
contentType="text/html;charset=ISO-8859-1"
pageEncoding Строка Определяет кодировку символов страницы JSP. По умолчанию используется charset из атрибута contentType , если оно там определено. Если значение charset в атрибуте contentType не определено, значение pageEncoding устанавливается равным ISO-8859-1

Директива taglib

Директива taglib объявляет, что данная страница JSP использует библиотеку тегов, уникальным образом идентифицируя ее с помощью URI, и ставит в соответствие префикс тега, с помощью которого возможны действия в библиотеке. Если контейнер не может найти библиотеку тегов, возникает фатальная ошибка трансляции. Директива taglib имеет следующий синтаксис: <%@ taglib uri="URI включаемой библиотеки тегов " prefix="имяПрефикса " %> Префикс "имяПрефикса " используется при обращении к библиотеке. Пример использования библиотеки тегов mytags : <%@ taglib uri="http://www.taglib/mytags" prefix="customs" %> . . . В данном примере библиотека тегов имеет URI-адрес "http://www.taglib/mytags" , в качестве префикса назначена строка customs , которая используется в странице JSP при обращении к элементам библиотеки тегов.

Директива include

Директива include позволяет вставлять текст или код в процессе трансляции страницы JSP в сервлет. Синтаксис директивы include имеет следующий вид: <%@ include file="Относительный URI включаемой страницы " %> Директива include имеет один атрибут - file . Она включает текст специфицированного ресурса в файл JSP. Эту директиву можно использовать для размещения стандартного заголовка об авторских правах на каждой странице JSP: <%@ include file="copyright.html" %> Контейнер JSP получает доступ к включаемому файлу. Если включаемый файл изменился, контейнер может перекомпилировать страницу JSP. Директива include рассматривает ресурс, например, страницу JSP, как статический объект. Заданный URI обычно интерпретируется относительно JSP страницы, на которой расположена ссылка, но, как и при использовании любых других относительных URI, можно задать системе положение интересующего ресурса относительно домашнего каталога WEB-сервера добавлением в начало URI символа "/". Содержимое подключаемого файла обрабатывается как обычный текст JSP и поэтому может включать такие элементы, как статический HTML, элементы скриптов, директивы и действия. Многие сайты используют небольшую панель навигации на каждой странице. В связи с проблемами использования фреймов HTML часто эта задача решается размещением небольшой таблицы сверху или в левой половине страницы, HTML код которой многократно повторяется для каждой страницы сайта. Директива include - это наиболее естественный способ решения данной задачи, избавляющий разработчика от кошмара рутины копирования HTML в каждый отдельный файл. Поскольку директива include подключает файлы в ходе трансляции страницы, то после внесения изменений в панель навигации требуется повторная трансляция всех использующих ее JSP страниц. Если же подключенные файлы меняются довольно часто, можно использовать действие jsp:include , которое подключает файл в процессе обращения к JSP странице.

Объявления JSP

Declarations (Declarations) предназначены для определения переменных и методов на языке скриптов, которые в дальнейшем используются на странице JSP. Синтаксис declarations имеет следующий вид: <%! код Java %> Объявления располагаются в блоке объявлений, а вызываются в блоке выражений страницы JSP. Код в блоке объявлений обычно пишется на языке Java, однако серверы приложений могут использовать синтаксис и других скриптов. Объявления иногда используются для того, чтобы добавить дополнительную функциональность при работе с динамическими данными, получаемыми из свойств компонентов JavaBeans. Примеры объявлений представлены в таблице. Объявление может содержать несколько строк, как например, в приведенном ниже коде вычисления значения функции fact (int n) , которая должна быть равна 1 при n меньше 2 и n! при положительном значении n; <%! public static int fact (int n) { if (n Объявления не производят никакого вывода в стандартный выходной поток out . Переменные и методы, декларированные в объявлениях , инициализируются и становятся доступными для скриптлетов и других объявлений в момент инициализации страницы JSP.

Скриптлеты JSP

Скриптлеты включают различные фрагменты кода, написанного на языке скрипта, определенного в директиве language . Фрагменты кода должны соответствовать синтаксическим конструкциям языка скриптлетов , т.е., как правило, синтаксису языка Java. Скриптлеты имеют следующий синтаксис: <% текст скриптлета %> Эквивалентом синтаксиса скриптлета для XML является: текст скриптлета
Если в тексте скриптлета необходимо использовать последовательность символов %> именно как сочетание символов, а не как тег - признак окончания скриптлета , вместо последовательности %> следует использовать следующее сочетание символов %\>.
В спецификации JSP приводится простой и понятный пример скриптлета , обеспечивающего динамическое изменение содержимого страницы JSP в течение дня. <% if (Calendar.getInstance ().get (Calendar.AM_PM) == Calendar.AM) {%> Good Morning <% } else { %> Good Afternoon <% } %> Необходимо заметить, что код внутри скриплета вставляется в том виде, как он записан, и весь статический HTML-текст (текст шаблона) до или после скриплета конвертируется при помощи оператора print . Это означает что скриплеты не обязательно должны содержать завершенные фрагменты на Java, и что оставленные открытыми блоки могут оказать влияние на статический HTML-текст вне скриплета . Скриплеты имеют доступ к тем же автоматически определенным переменным, что и выражения. Поэтому, например, если есть необходимость вывести какую-либо информацию на страницу, необходимо воспользоваться переменной out . <% String queryData = request.getQueryString (); out.println ("Дополнительные данные запроса: " + queryData); %>

Выражения JSP

Выражение в странице JSP - это исполняемое выражение, написанное на языке скрипта, указанного в объявлении language (как правило Java). Результат выражения JSP, имеющий обязательный тип String , направляется в стандартный поток вывода out с помощью текущего объекта JspWriter . Если результат выражения не может быть приведен к типу String , возникает либо ошибка трансляции, если проблема была выявлена на этапе трансляции, либо возбуждается исключение ClassCastException , если несоответствие было выявлено в процессе выполнения запроса. Выражение имеет следующий синтаксис: <%= текст выражения %> альтернативный синтаксис для выражений JSP при использовании XML: текст выражения Порядок выполнения выражений в странице JSP слева-направо. Если выражение появляется более чем в одном атрибуте времени выполнения, то оно выполняется слева-направо в данном теге. Выражение должно быть полным выражением на определенном скрипте (как правило Java). Выражения выполняются во время работы протокола HTTP. Значение выражения преобразуется в строку и включается в соответствующую позицию файла JSP. Выражения обычно используются для того, чтобы вычислить и вывести на экран строковое представление переменных и методов, определенных в блоке объявлений страницы JSP или полученных от компонентов JavaBeans, которые доступны из JSP. Следующий код выражения служит для отображения даты и времени запроса данной страницы: Текущее время: <%= new java.util.Date () %> Для того чтобы упростить выражения существует несколько заранее определенных переменных, которые можно использовать. Наиболее часто используемые переменные:
  • request, HttpServletRequest;
  • response, HttpServletResponse;
  • session, HttpSession - ассоциируется с запросом, если таковой имеется;
  • out, PrintWriter - буферизированный вариант типа JspWriter для отсылки данных клиенту.

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

  • Object - класс от которого наследуются все объекты в Java, включая массивы и строки ().
  • Спецификаторы доступа индивидуальны для каждого члена (указываются перед объявлением).
  • Все члены класса по умолчанию открыты для области видимости пакета . Область видимости "по умолчанию" - это нечто среднее между private и protected , см. .
  • Каждый *.java файл может содержать только один класс объявленный как public и доступный извне.
  • Определение и объявление класса всегда находится в одном файле, невозможно вынести прототипы в заголовки.
  • Отсутствуют указатели.
  • Все переменные классов - на самом деле ссылки на объекты а не сами объекты. Инициализация их для использования обязательно должна выполняться через new <конструктор-класса>(...) .
  • Исходя из предыдущего пункта - при присвоении одной переменной-объекта другой выполняется только изменение ссылки но не копирование объекта.
  • Переменные в функции передаются по значению если это элементарные типы (int, byte, long, etc...), или по ссылке, если это объекты.
  • Доступ к публичным статическим членам класса осуществляется через оператор точки. , а не через:: , что на мой взгляд вносит некоторую внешнюю путанницу.
  • Отсутствует деструктор, но есть finalize() .
  • Не стоит путать finalize() и деструктор С++. finalize() вызывается только при сборке мусора , которая никак не связана с выходом объекта из области видимости и отсутствием хотя бы одной ссылки на данный объект.
  • Сборку мусора можно форсировать вызвав метод Runtime.gc() на текущем объекте Runtime или статический метод System.gc() . Судя по проведённым опытам - освобождение памяти работает только в пределах виртуальной машины Java и однажды выделенную память в ОС не возвращает пока не завершится машина.
  • В Java-стиле написания кода функции генерируют исключения, вместо возврата кода системной ошибки или ошибки логики виртуальной машины. Потому множество функций обязательно должно выполняться внутри блока try { ... } catch (...) { ... } обрабатывающего исключения, либо метод вызывающий их должен явно указывать через throws список не обрабатываемых им исключений генерируемых этими функциями, для обработки их методами "выше" по стеку вызовов.
  • Исключения делятся на и .
  • Блок try { ... } также может заканчиваться блоком finally { ... } , выполняющемся независимо от наличия/отсутствия исключений в предыдущем блоке try { ... } . Это удобно использовать для выполнения каких-либо обязательных действий независимо от результатов выполнения блока кода, например для автоматического освобождения всех выделенных в нём ресурсов.
  • char это не однобайтный тип как с С/С++, это 16-битный тип поддерживающий unicode строки.
  • bool в Java известен как boolean .
  • Условные конструкции принимают только boolean тип переменных или выражений. Это значит что код вида:
    int a; ... действия над переменной a ...; if(a) { ... }
    Не верен с точки зрения Java синтаксиса и не будет скомпилирован.
  • Константы объявляются словом final а не const .
  • Все массивы - объекты.
  • Даже строковые константы (например "any string const") являются объектами.
  • Для строк (класс String) определён только один оператор - + , конкатенация.
  • Сравнение строк выполняется через метод bool equals() класса String , например s1.equals(s2) .
  • Содержимое объектов-строк (String) константно и не подразумевает изменения отдельного элемента строки, это сделано в целях повышения производительности. При необходимости подобных операций можно использовать класс StringBuffer .
  • При конкатенации не инициализированной строки с не пустой строкой получится null + не-пустая-строка , например s += "|string"; будет равно "null|string"
  • Массивы имеют переменную-член с публичным доступом length , строки не имеют , вместо этого в них используется метод length() .
  • Java не поддерживает множественного наследования. Отчасти его функции выполняются через "интерфейсы" (interface). Интерфейсы поддерживают множественное "наследование"-реализацию (implements) нескольких интерфейсов в одном классе, и в целом отношения "многие (интерфейсы) ко многим (классам)" и наоборот.
  • Интерфейсы допускают создание ссылок через которые можно обращаться к объектам классов реализующих эти интерфейсы. Правда динамический поиск подходящего метода при обращении через ссылку-интерфейс требует много накладных расходов, потому не желателен.
  • Вместо перечислений enum можно использовать интерфейсы без объявлений методов в них. В таком случае все переменные интерфейса должны быть инициализированны при определении интерфейса и их значения автоматически будут константны. После этого, через implements их можно "подключать" в определяемый класс.
  • Так же, начиная с JDK 5 существуют внешне классические перечисления - enum . На самом деле это не просто список именованных констант, а специальный класс наследуемый от суперкласса Enum . Каждый элемент перечисления - объект этого класса. Числовое значение объекта перечисления можно получить встроенной функцией ordinal .
  • Пользовательсякая перегрузка операторов привычная в С++, в Java не поддерживается .
  • Для работы в объектной среде с "примитивными типами" (int, float, char, etc...) в Java используется автоупаковка/автораспаковка в типы-оболочки (Integer, Float, Character, etc...). По сути это реализация перегрузки операторов для нескольких встроенных классов реализующих функционал примитивных типов + объектные методы.
  • super - ключевое слов опозволяющее вызвать конструктор суперкласса из подкласса, либо обратиться к члену суперкласса скрытого членом подкласса.
    • В случае использования в качестве конструктора - super всегда должен быть первым оператором в конструкторе подкласса.
  • Для определения абстрактных методов используется ключевое слово abstract , класс содержащий абстрактный метод так же должен определяться как abstract class ... .
  • final запрещает переопределять методы в дочерних классах. Для "коротких" методов объявленных как final , это ключевое слово оказывает эффект аналогичный inline в С++ - в подклассах вместо вызова функции может быть вставлен байт-код метода суперкласса в код метода вызывающего класса.
  • final также запрещает наследовать класс объявленный как final .
  • Пространства имён (namespace) в Java реализуются как пакеты (package).
  • Для подключения пакетов используется import , так же можно использовать import static ..(*|) для импорта статических членов класса.
  • Java поддерживает потоки через встроенный класс Thread и интерфейс Runable . Для синхронизации используется спецификатор synchronized перед методом в описании класса, или synchronized() { ... } для блока кода синхронизируемого с . Для сигналов между синхронизированными потоками используются методы родительского класса Object: wait()/notify()/notifyAll() .
  • transient - модификатор сообщающий что значение объекта/переменной не нужно "удерживать" при сохранении объекта, например при сериализации его перед записью на диск/в БД. Логично таким образом помечать переменные содержащие уникальные идентификаторы времени выполнения и прочую подобную информацию имеющую смысл только в текущем экземпляре java-процесса.
  • instanceof - операция времени выполнения, возвращает true если есть ссылка на класс , либо может быть приведён к ссылке на этот класс, иначе false .
  • assert - утверждения в Java используются примерно так же как и в С: assert [: Assertion fail description] , но нужно иметь ввиду что они "вшиваются" в скомпилированный байт-код, и могут быть включены при запуске java -ea .
  • this(...) - может быть использовано внутри конструктора класса для вызова другого конструктора этого же класса, подходящего по сигнатуре аргументов.
  • Вместо шаблонов используются обобщения , внешне очень похоже: class CLASS_NAME { ... } . В обобщениях нельзя использовать примитивные типы (int, byte, char, etc... ). В качестве параметров могут быть использованы только классы .
    Кроме того, поддерживаются ограниченные типы , через указание суперкласса для классов-параметров. Например, объявление "обобщённого класса" class CLASS_NAME в котором допустимо использовать только классы-потомки общего класса числовых Number .
  • Для быстрого копирования массивов удобно применять System.arraycopy() .
  • Одним из фундаментальных элементов многих языков программирования являются условные конструкции . Данные конструкции позволяют направить работу программы по одному из путей в зависимости от определенных условий.

    В языке Java используются следующие условные конструкции: if..else и switch..case

    Конструкция if/else

    Выражение if/else проверяет истинность некоторого условия и в зависимости от результатов проверки выполняет определенный код:

    Int num1 = 6; int num2 = 4; if(num1>num2){ System.out.println("Первое число больше второго"); }

    После ключевого слова if ставится условие. И если это условие выполняется, то срабатывает код, который помещен в далее в блоке if после фигурных скобок. В качестве условий выступает операция сравнения двух чисел.

    Так как, в данном случае первое число больше второго, то выражение num1 > num2 истинно и возвращает значение true . Следовательно, управление переходит в блок кода после фигурных скобок и начинает выполнять содержащиеся там инструкции, а конкретно метод System.out.println("Первое число больше второго"); . Если бы первое число оказалось бы меньше второго или равно ему, то инструкции в блоке if не выполнялись бы.

    Но что, если мы захотим, чтобы при несоблюдении условия также выполнялись какие-либо действия? В этом случае мы можем добавить блок else:

    Int num1 = 6; int num2 = 4; if(num1>num2){ System.out.println("Первое число больше второго"); } else{ System.out.println("Первое число меньше второго");

    Int num1 = 6; int num2 = 8; if(num1>num2){ System.out.println("Первое число больше второго"); } else if(num1

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

    Int num1 = 8; int num2 = 6; if(num1 > num2 && num1>7){ System.out.println("Первое число больше второго и больше 7"); }

    Здесь блок if будет выполняться, если num1 > num2 равно true и одновременно num1>7 равно true .

    Конструкция switch

    Конструкция switch/case аналогична конструкции if/else , так как позволяет обработать сразу несколько условий:

    Int num = 8; switch(num){ case 1: System.out.println("число равно 1"); break; case 8: System.out.println("число равно 8"); num++; break; case 9: System.out.println("число равно 9"); break; default: System.out.println("число не равно 1, 8, 9"); }

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

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

    Case 8: System.out.println("число равно 8"); num++; case 9: System.out.println("число равно 9"); break;

    то так как у нас переменная num равно 8, то выполнился бы блок case 8 , но так как в этом блоке переменная num увеличивается на единицу, оператор break отсутствует, то начал бы выполняться блок case 9 .

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

    Начиная с JDK 7 в выражении switch..case кроме примитивных типов можно также использовать строки:

    Package firstapp; import java.util.Scanner; public class FirstApp { public static void main(String args) { Scanner in = new Scanner(System.in); System.out.println("Введите Y или N: "); String input= in.nextLine(); switch(input){ case "Y": System.out.println("Вы нажали букву Y"); break; case "N": System.out.println("Вы нажали букву N"); break; default: System.out.println("Вы нажали неизвестную букву"); } } }

    Тернарная операция

    Тернарную операция имеет следующий синтаксис: [первый операнд - условие] ? [второй операнд] : [третий операнд] . Таким образом, в этой операции участвуют сразу три операнда. В зависимости от условия тернарная операция возвращает второй или третий операнд: если условие равно true , то возвращается второй операнд; если условие равно false , то третий. Например:

    Int x=3; int y=2; int z = x

    Здесь результатом тернарной операции является переменная z. Сначала проверяется условие x

    Станислав Горнаков

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

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

    Класс Телефон { Метод Включить() { // операции по включению телефона } Метод Выключить() { // операции по выключению телефона } }

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

    А теперь давайте запишем тот же самый класс только уже на языке Java.

    Class Telefon { void on() { // тело метода on() } void off() { // тело метода off() } }

    Ключевое слово class в языке Java объявляет класс, далее идет название самого класса. В нашем случае это Telefon. Сразу пару слов касательно регистра записи. Почти во всех языках программирования важно сохранять запись названий в том регистре, в котором она была сделана. Если вы написали Telefon, то уже такое написание как telefon или TELefoN выдаст ошибку при компиляции. Как написали первоначально, так и надо писать дальше.

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

    В теле класса Telefon имеются два метода: on() – включающий телефон и метод off() – выключающий телефон. Оба метода имеют свои тела и в них по идее должен быть какой-то исходный код, описывающий необходимые действия обоих методов. Для нас сейчас неважно, как происходит реализация этих методов, главное – это синтаксис языка Java.

    Оба метода имеют круглые скобки on(), внутри которых могут быть записаны параметры, например on(int time) или on(int time, int time1). С помощью параметров происходит своего рода связь методов с внешним миром. Говорят, что метод on(int time) принимает параметр time. Для чего это нужно? Например, вы хотите, чтобы телефон включился в определенное время. Тогда целочисленное значение в параметре time будет передано в тело метода и на основе полученных данных произойдет включение телефона. Если скобки пусты, то метод не принимает никаких параметров.

    Комментарии

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

    Комментарии в Java могут быть трех видов, это: //, /*…*/ и /**…*/. Комментарии, записанные с помощь оператора // должны располагаться в одной строке:

    // Одна строка!!! Ошибка! На вторую строку переносить нельзя! // Первая строка // Вторая строка // … // Последняя строка

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

    Типы данных Java

    Чтобы задать произвольное значение, в Java существуют типы данных. В классе Telefon мы создали два метода. Оба метода не имели параметров, но когда приводился пример метода on(int time) с параметром time, говорилось о передаче значения в метод. Данное значение указывало на время, с помощью которого якобы должен включиться телефон. Спецификатор int как раз и определяет тип значения time. В Java 2 МЕ шесть типов данных.

    Byte – маленькое целочисленное значение от –128 до 128;
    short – короткое целое значение в диапазоне от –32768 до 32767;
    int – содержит любое целочисленное значение от –2147483648 до 2147483647;
    long – очень большое целочисленное значение, от –922337203685475808 до 9223372036854775807;
    char – это символьная константа в формате Unicode. Диапазон данного формата от 0 до 65536, что равно 256 символам. Любой символ этого типа должен записываться в одинарных кавычках, например: ‘G’;
    boolean – логический тип, имеет всего два значения: false – ложь и true – истина. Этот тип часто используется в циклах о которых чуть позже. Смысл очень прост – если у вас в кармане есть деньги, предположительно это true, а если нет то false. Таким образом, если деньги имеются – идем в магазин за хлебом или пивом (нужное подчеркнуть), если нет денег – остаемся дома. То есть это такая логическая величина, которая способствует выбору дальнейших действий вашей программы.

    Чтобы объявить какое-то необходимое значение используется запись:

    Int time; long BigTime; char word;

    Оператор точка с запятой необходим после записей и ставится в конце строки. Можно совместить несколько одинаковых по типу объявлений через запятую:

    Mt time, time1, time2;

    Теперь давайте, усовершенствуем наш класс Telefon, добавив в него несколько значений. Методы on() и off() нам больше не нужны, добавим новые методы, которые действительно могут решать определенные задачи.

    Class Telefon { //S – площадь дисплея //w – ширина дисплея //h – высота дисплея int w, h, S; //метод, вычисляющий площадь дисплея void Area() { S = w*h; } }

    Итак, мы имеем три переменные S, w и h, отвечающие, соответственно, за площадь, ширину и высоту дисплея в пикселях. Метод Area() вычисляет площадь экрана телефона в пикселях. Операция бесполезная, но очень показательная и простая в понимании. Тело метода Area() обрело себя и имеет вид S = w*h. В этом методе мы просто перемножаем ширину на высоту и присваиваем или как еще говорят, сохраняем результат в переменной S. Эта переменная будет содержать значения площади дисплея данного телефона. Сейчас мы подошли вплотную к операторам языка Java, с помощью которых можно совершать всевозможные операции и о которых мы поговорим уже в следующей части данной серии статей.




    Рассказать друзьям