Назначение, особенности и преимущества Eclipse

Eclipse - это расширяемая IDE (интегрированная среда разработки). IDE - удобно организованный набор инструментов, необходимых для работы над программным проектом.

Eclipse - универсальная платформа, которая может использоваться для разработки приложений на любом языке программирования (например, можно использовать язык Python после установки подключения Pydev (), но изначально «родным» для Eclipse является Java (на которой, кстати, сам Eclipse и написан).

Наиболее важными особенностями Eclipse являются:

1. Кроссплатформенность. Eclipse выполняется на всех распространенных платформах: Windows, Linux и MacOS X. Еще важнее то, что его функции одинаковы на каждой из этих платформ.
2. Универсальность и расширяемость. В Eclipse реализована возможность использова­ния различных инструментов, разработанных сторонними программистами.
3. Открытость и бесплатность. Eclipse является OpenSource-проектом (т.е. его исходные коды доступны любому желающему и кто угодно может присоединиться к разработке этого инструмента). Eclipse имеет активное сообщество, постоянно работающее над улучшением программы и расширением ее возможностей.

Рабочая среда Eclipse

Первое, что вы видите при запуске Eclipse – диалоговое окно, позволяющее выбрать место, где будет располагаться рабочее пространство. Рабочее пространство – каталог, в ко­тором будет сохраняться ваша работа.

После выбора рабочего пространства, на экране появится начальная страница, с предложениями посмотреть учебники, примеры и т.д. Выберите Workbench и вы перейдете в окно рабочей среды (Workbench), в котором и будет проходить ваша дальнейшая работа.

Основными составляющими рабочей среды являются представления (views), редакто­ры (editors) и проекции или перспективы (perspectives).

Представление – это небольшой раздел внутри рабочей среды, который служит для навигации по неко­торой категории объектов (такой, как ресурсы или пакеты), открытия редакторов, отображения свойств активных редакторов. Например, представ­ление Navigator показывает проекты и дру­гие ресурсы, а представление Bookmarks отображает все закладки в Workbench вме­сте с именами файлов, с которыми эти за­кладки связаны. На рисунке изображен пра­вый верхний угол ра­бочей среды с ак­тивным представление Outline.

Все измене­ния, сде­ланные в представлениях, немедлен­но сохраняют­ся.

Другой тип визуальных компонентов Workbench – редакторы , которые используются для просмотра и редактирования некоторого ре­сурса (например, программного кода). При выборе ресурса появляется подходящий редактор. Например, откройте любой текстовый до­кумент (с расширением.txt) командой File --> Open File... и вы увидите встроенный редактор простого неформатируемого текста. Если что-либо набрать в этом редакторе, на его вкладке, где написано название файла, появится звездочка. Она означает, что редактор содержит не сохраненные изменения. Они сохранятся, если нажать Ctrl + S или выбрать команду File --> Save .

Существует множество полезных представлений, которые добавляются в окно рабочей среды командой Window --> Show View . Однако вместо того, чтобы добавлять их по одному, удобнее бывает переключать проекцию (perspective). Проекция (или перспектива ) – это набор представлений и редакторов, специально подобранный для выполнения некоторой задачи. После запуска в Eclipse открывается перспектива Java, настроенная собственно на написание программы. Для отладки программы часто используется проекция Debug. Переключить проекцию можно командой Window --> Open Perspective . На­звание текущей проекции отображается в правом верхнем углу рабочей среды (см. рисунок).

Первая программа на Java

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

Для создания проекта выполните команду File --> New --> Project . В появившемся окне выберите Java Project и нажмите «Далее». Укажите имя своего проекта. Обратите внимание, что в директории, указанной вами как рабочее пространство, будет создана папка с именем вашего проекта (если, конечно, не изменить настройки в этом окне, чего для первого раза мы делать не будем). Нажмите кнопку «Готово».

Теперь в представлении PackageExplorer в левой части рабочей среды присутствует ваш проект. В любой момент его можно удалить, щелкнув по его названию правой кнопкой мыши и выбрав Delete . После этого Eclipse спросит, уничтожить ли заодно папку с файлами проекта (при необходимости можно и уничтожить).

Если вы не удалили проект, к нему можно добавить файлы и папки с помощью команд контекстного меню New --> File и New --> Folder соответственно. Если проект большой, то ему необходима структура вложенных папок. Но в случае Java-проекта все несколько иначе. Дело в том, что фрагменты Java-программы сгруппированы в пакеты , а для каждого пакета создается отдельная папка. Пакет создается командой New --> Package . Для пакета тоже надо придумать имя. В результате в папке проекта будет создана новая папка с этим именем. Можете проверить.

Просматривать ресурсы проекта может быть удобнее с помощью представления Navigator. Откройте его командой Window --> Show View . Вы увидите, что кроме директо­рий проекта и пакета Eclipse создал два вспомогательных файла.classpath и.project. Они лег­ко откроются в редакторе, но особого интереса для нас они сейчас не представляют.

Программа на Java всегда состоит из одного или нескольких классов . Создать класс можно командой New --> Class в контекстном меню представления Navigator (или Package Explorer, не имеет значения). При создании класса необходимо выбрать пакет, к которому он будет относиться (выберите только что созданный вами пакет) и придумать ему имя. Имена классов принято начинать с прописной буквы. Если не соблюсти это правило хорошего тона, Eclipse выдаст предупреждение, но ничего страшного не произойдет.

Для наших целей полезно поставить галочку в разделе «Какие методы вы хотите со­здать в своем классе?» напротив опции public static void main(String args) . В результате в теле класса будет сгенерирован метод (функция) main() . Java требует, чтобы хотя бы в одном из классов программы существовал метод с таким заголовком. Именно он и будет выполнен при старте программы.

В результате наших действий в папке пакета будет создан файл с именем нашего класса и расширением.java. Eclipse откроет редактор кода, в котором отобразится содержимое этого файла. Оно будет примерно следующим (имена пакета и класса, конечно, могут отличаться):

package mainPack; public class MyClass { /** * @param args */ public static void main(String args) { } }

Команды, составляющие тело функции, можно написать вместо автоматически сгене­рированного комментария // TODO Auto-generated method stub . Мы напишем только одну команду, которая будет выводить на экран классическую строку «Hello, world!»:

System.out.println("Hello, world!" );

Осталось программу запустить. Для этого выполним команду Run --> Run и получим диалоговое окно с нетривиальными настройками запуска. В левой части этого окна надо вы­брать Java Application (приложение Java). Немного подумав, Eclipse найдет наш класс, содер­жащий метод main() и предложит начать запуск программы именно с него (в правой части окна на вкладке Main должны появиться названия нашего проекта и нашего класса). Помимо этого вниманию программиста предлагается еще несколько закладок. Например, на второй из них – Arguments – предлагается ввести параметры командной строки (если программа рас­считана на вызов из командной строки с параметрами). Для нашей простой программы ниче­го дополнительно указывать не нужно. Просто нажмите кнопку Run .

В результате работы программы осуществляется вывод данных в так называемую консоль. В операционной системе MS DOS консолью служил весь экран монитора. Eclipse же открывает нам представление Console, в котором (если все сделано правильно) и отобразится строка "Hello, world!" - результат вывода нашей программы.

Теперь для повторного запуска программы (например, если мы решили внести в нее ка­кие-то изменения или надо показать преподавателю), можно пойти более легким путем - выполнить команду Run --> Run Last Launched (еще раз запустить предыдущее приложение) или просто нажать Ctrl + F11 .

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

Определения

Операнд - величина, участвующая в операции.

Метод (функция) - часть программы, имеющая собственное имя. Это имя можно использовать в программе как команду (такая команда называется вызовом метода). При вызове метода выполняются команды, из которых он состоит. Метод аналогично операции может возвращать значение-результат.

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

Переменная – именованная область памяти ЭВМ, в которой программа может хранить данные определенного типа (называемые значением переменной ) и обращаться к этим данным, используя имя переменной.

Понятия программы и алгоритма (повторение)

Назначение любой компьютерной программы - преобразование входных данных в вы­ходные данные. Алгоритм программы определяет способ преобразования входных данных в выходные.

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

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

Приступая к написанию программы НЕОБХОДИМО СРАЗУ ПОНЯТЬ:

1. Для чего вообще нужна эта программа (что она делает, в общих чертах)?
2. Какие у этой программы входные данные (и откуда они берутся)?
3. Какие у этой программы выходные данные (и куда их отправить)?
4. Каким образом входные данные должны быть преобразованы в выходные (алгоритм)? Это самая сложная часть раздумий программиста, но пока нет ответа на три предыдущих вопроса, приступать к ней не имеет смысла.

При написании простой программы необходимо:

1. Получить входные данные.
2. Реализовать алгоритм превращения входных данных в выходные.
3. Выдать результат работы программы (выходные данные): вывести на экран, передать по сети и т.п.

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

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

Литература по теме:

Основные конструкции алгоритма (повторение)

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

Итак, алгоритм - это последовательность действий по преобразованию входных дан­ных в выходные.

Алгоритм может быть записан тремя основными способами:

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

Последовательное выполнение. Шаги выполняются друг за другом.

Ветвление. В зависимости от выполнения некоторого условия (в рассмотренном при­мере это x > y ?) выполняется та или иная ветвь программы.

Циклы. Последовательность шагов программы выполняется несколько раз. По сути цикл основан на ветвлении (проверяется условие выхода из цикла), но при невыполнении этого условия управление передается в начало цикла (назад, к уже выполненному шагу).

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

Первая диаграмма выглядит понятнее, но в случае, когда вывести надо не 5 чисел, а 100, диаграмма (и программа, соответствующая этому алгоритму) увеличится в 20 раз, а в программе, соответствующей второму алгоритму, изменится только одно место: 10 поменяется на 100. Именно поэтому повторяющиеся действия оформляют в виде циклов, хотя во многих случаях без них можно и обойтись.

Запомните: алгоритм должен строиться только из трех названных конструкций!

Литература по теме:

1. Школьный учебник информатики.

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

1. Язык Java различает прописные и строчные буквы. Это означает, что имена всех функций и ключевые слова следует записывать в точности так, как они значатся в примерах и справочниках.
2. Каждая команда (оператор) в языке Java должна заканчиваться точкой с запятой.
3. Программа на Java состоит из одного или нескольких классов . Абсолютно вся функциональная часть программы (т.е. то, что она делает) должна быть помещена в методы тех или иных классов. (Класс и метод, как понятия объектно-ориентированного программирования, будут рассматриваться в третьем занятии. Там же будет рассмотрен синтаксис классов. В первых упражнениях используйте классы, которые по умолчанию генерирует Eclipse.)
4. Классы группируются в пакеты.
5. Хотя бы в одном из классов должен существовать метод main() , в точности такой, как в рассмотренном нами примере. (На первых порах разбираться или пытаться запомнить правильное написание этого метода необязательно – Eclipse все сгенерирует сам, если поста­вить нужную галочку.) Именно этот метод и будет выполняться первым.

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

public static void main(String args) {

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

Комментарии

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

1. Ставятся две косые черты // . С этого момента и до конца строки можно писать все, что угодно - Java будет считать это комментарием.
2. В начале комментария ставятся символы /* , а в конце - */ . В этом случае комментарий может занимать какое угодно количество строк.
3. Особо выделяются комментарии для документирования , которые помещаются меж­ду маркерами /** и */ . Об их использовании будет рассказано позже.

Правила записи литералов

о разных формах записи литералов

Целые числа (целочисленные литералы) в Java можно записывать обычным образом в де­сятичной форме: 12345, +4, -11.

Кроме этого, можно записывать целые числа в восьмеричной форме, на­чиная с нуля (0777, -056) и в шестнадцатеричной форме, начиная с нуля и латинской буквы x (0xFFFF, 0x14, 0xA1BC).

Действительные литералы записываются в десятичной системе счисления, целая часть отделяется от дробной точкой.

Действительное число можно записать в форме с плавающей точкой , например: 5.4e19, 17E-11, -123e+4. Та часть числа, которая стоит до буквы e называется мантиссой, а часть, ко­торая стоит после буквы e – порядком. Запись означает следующее: надо возвести 10 в сте­пень порядка и умножить на мантиссу. Иногда действительно удобнее записать 1e-9, чем 0.000000001.

Одиночные символы записываются в апострофах, например, "a" , "D" , "@" .

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

Управляющая последовательность также заключается в апострофы.

В первой строке таблицы говорится, что любой символ можно задать с помощью его кода (с десятичной кодировкой от 0 до 255), записав этот код в восьмеричной системе счисления. Например, буква "ж" в кодировке CP1251 запишется управляющей последовательностью "\346"

При необходимости можно указать код любого символа в кодировке Unicode – после обратной черты и латинской буквы u – четырьмя шестнадцатеричными символами. Например, "\u0055" – это буква U.

Строки символов записываются в кавычках. Открывающая и закрывающая ка­вычка должны находиться в одной строке программного кода.

Для строк определена операция сцепления +, которая позволяет собрать несколько строк в одну ("приписывая" их друг к другу).

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

"Это очень длинная строковая константа, записанная" + "на двух строках исходного текста"

Управляющие символы и коды записыва­ются внутри строки точно также с обратной чертой (но без апострофов).

Логические литералы - это true (истина) и false (ложь).

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

о правилах хорошего стиля

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

Идентификатор может состоять из букв, цифр, знака подчеркивания _ и знака доллара $ (последний использовать не рекомендуется, Java пользуется им для своих нужд). Идентификатор не может начинаться с цифры. В качестве идентификаторов не могут использоваться ключе­вые слова Java (а также литералы true, false и null ).

Как было отмечено выше, язык Java различает простые и строчные буквы . Это значит, что myAge , myage и MyAge – имена совершенно разных объектов. Будьте внимательны: ошибка в регистре - весьма распространенный случай!

Имена классов начинаются с прописной буквы, если имя состоит из нескольких слов, то каждое слово начинается с прописной буквы. Например: MyClass , Book .

Имена методов и переменных начинаются со строчных (маленьких букв); если в имени содержится несколько слов, то каждое следующее слово начинается с заглавной буквы. Например, myVar , x , y , newBigCounter .

Имена констант записываются полностью прописными буквами; если имя содержит несколь­ко слов, между ними ставится знак подчеркивания. Например, PI , COUNT_OF_MONTHS.

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

Типы данных

о типах данных Java

Для хранения целых чисел в Java чаще всего используется тип int .

Вообще в языке Java существует четыре целочисленных типа: byte , short , int , long . Они различаются объемом памяти, которая будет выделена под переменную и, соответственно, диапазоном значений, которые можно в этой переменной хранить. Чаще всего используемый тип int занимает в памяти 4 байта и пригоден для хранения чисел от -2147483648 до 2147483647. Тип byte расходует меньше всего памяти и подходит для работы с небольшими числами (от -128 до 127). Типы short и long занимают 2 и 8 байт соответственно.

Для действительных чисел подходит тип double .

Действительные (вещественные) числа (или числа с плавающей точкой) представлены двумя типами: float и double . Тип float занимает 4 байта памяти и не дает большой степени точности при работе с очень большими или очень маленькими числами. Его рекомендуют использовать в случае, когда дробная часть нужна, но высокая точность не требуется (например, для измерения расстояний в метрах, но с учетом сантиметров и миллиметров или измерения цен в рублях с учетом копеек). При необходимости более точных вычислений рекомендуется оперировать с величинами типа double (например, такая переменная может хранить величину синуса угла).

Действительные литералы, такие как 5.3 , 8.0 , 2e-3 , Java считает относящимися к типу double . Если они должны использоваться в программе как величины типа float , необходимо заканчивать их на букву f: 5.3f , 8.0f , 2e-3f .

Для хранения одиночных символов используется тип char . Java считает его разновидностью целочисленных типов (поскольку каждый символ задается своим кодом в кодировке Unicode), так что к char применимы все операции с целыми числами.

Логические величины (принимающие истинное либо ложное значение) представлены типом boolean .

Таким образом, в Java определено восемь простых типов, особенности которых представлены в таблице:

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

В языке Java (как и во многих других языках) требуется описать перед ее использованием. Описать переменную – значит дать ей имя и определить ее тип.

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

Примеры объявления переменных:

int x; // Объявление целочисленной переменной x double a, b; // Объявление двух вещественных переменных a и b char letter = "Z "; // Объявление символьной переменной letter, инициализация начальным значением "Z" boolean b1 = true , b2, b3 = false ; // Объявление трех логических переменных, первая из них будет иметь значение true, последняя - false

Ocновные операции языка

Переменные и могут участвовать в (из которых, в свою очередь могут строиться сложные ). Рассмотрим простейшие операции языка Java.

Математические операции

Операции сравнения, результатом является значение логического типа: true (истина) или false (ложь)

Логические операции

об операциях Java

Операции && и || отличаются тем, что не обязательно вычисляют значение второго . Например, && вычисляет значение первого операнда и, если оно ложно, сразу возвращает false , а || возвращает true сразу, если видит, что первый операнд – истина. В Java есть аналогичные по действию операции & и | , они вычисляют значения обоих операндов, прежде чем произвести над ними операцию.

Операции сдвига

(работают с битовым представлением первого операнда)

Битовые операции

(работают с битовым представлением операндов)

Операция?:

Операция?: тернарная, то есть имеет три операнда. Первый операнд - условие, выражение логического типа. Второй и третий операнды - выражения любого другого типа. Операция работает следующим образом: если условие равно true , она возвращает в качестве результата свой второй операнд, а если false , то третий.

Например, выражение (5 > 3)? 7+1: 2*2 будет иметь значение 8, а выражение (5 == 3)? 7+1: 2*2 - значение 4. Эта запись выглядит не очень наглядно, но программисты часто используют ее для сокращения своего кода. Так, вместо последовательности команд:

if (x > 0) y = 45 + a*2; // оператор if рассматривается ниже else y = 45 - b*3;

можно написать:

Y = 45 + ((x > 0)? a*2: -b*3);

Оператор присваивания

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

Значение связывается с переменной с помощью присваивания. В языке Java он записывается простым знаком равенства:

Переменная = выражение;

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

X = 7; // переменной x присваивается значение 7 letter = "Q" ; // переменной letter присваивается значение "Q"

В общем случае выражение - это то, что может быть вычислено (например, результат математической операции или результат, возвращаемый некоторым методом):

A = 7.5 + 2.4; // переменной a присваивается 9.9 как результат вычислений

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

B = a + 1;

переменная b примет значение 10.9.

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

X = x + 4;

Эта команда увеличивает текущее значение целочисленной переменной x на 4.

А следующие команды записаны неправильно и работать не будут:

5 = x + 7; // слева должна стоять переменная x + 3 = 14; // слева должна стоять просто одна переменная x = 4.5; // переменная x может принимать только целочисленные значения

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

о приведении типов

Когда переменной одного типа присваивается величина другого типа, происходит используется приведение (преобразование) типов . Для числовых типов (byte , short , int , long , float , double , char ) оно происходит автоматически, если тип изменяемой переменной может "вместить" значение другого типа.

Например, если переменной типа int присвоить значение типа byte , автоматически произойдет преобразование типа byte в тип int . Аналогично тип float может быть приведен к типу double и т.п.

При попытке присвоить переменной менее точного типа (например, byte ) значение более точного типа (например, int ) компилятор выдаст сообщение об ошибке.

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

long j = (long )1.0; //используем оператор приведения типа к long, j = 1 char ch = (char )1001; //используем оператор приведения типа к char, ch = "d" byte b2 = (byte )(100); //используем оператор приведения типа от int к byte, b2 = 100 byte b3 = (byte )(100 * 2); //внимание! происходит деление по модулю, b3 = -56

Ошибка несовпадения типов часто возникает применительно к действительным литералам. Например, нельзя выполнить присваивание a = 7.5 + 2.4; , если переменная a имеет тип float , поскольку литералы 7.5 и 2.4 считаются относящимся к типу double . Чтобы не было ошибки, необходимо использовать приведение типов:

A = (float)(7.5 + 2.4);

или указать, что литералы также относятся к типу float:

A = 7.5f + 2.4f; // это тоже правильная команда

Практически для каждой бинарной операции существует своя разновид­ность оператора присваивания. Например, для операции сложения + существует унарный оператор присваивания += , который увеличивает значение операнда на заданную величину:

X += 8; // то же самое, что x = x + 8 (x увеличивается на 8)

Аналогично для других операций: операторы *= , -= , /= , %= , &= ^= и т.д:

X *= 3; // то же самое, что x = x * 3 (x увеличивается в 3 раза) b1 ^= b2; // то же самое, что b1 = b1 ^ b2

Упражнение 1

Объявите две целочисленных переменных, присвойте им любые значения. Выведите их сумму и произведение.

Подсказка: вы можете воспользоваться уже созданным в Eclipse проектом, вставив нужные команды после команды вывода строки "Hello, world!" либо вместо нее.

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

об операторах инкремента и декремента

Операторы инкремента и декремента ++ и –– увеличивают и уменьшают на единицу значение операнда. Гораздо удобнее использовать команду x++; вместо команды x = x+1;

Операторы инкремента и декремента тоже возвращают значение. Это значит, что пра­вомерно выполнить команду

Y = 7 * x++;

В результате переменная x увеличится на 1, а переменная y примет значение, в семь раз большее старого значения x. Можно также выполнить и такую команду:

Y = 7 * ++x;

В результате переменная x увеличится на 1, а переменная y примет значение, в семь раз большее нового значения x.

Условный оператор if

Простейшая форма записи условного оператора имеет вид:

if (условие) команда

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

if (x // если значение переменной x меньше 17, x присвоить 17

Если же необходимо, чтобы в случае, когда условие ложно, была выполнена какая-то другая команда, используют расширенную форму оператора if:

if (условие) команда1 else команда2

о конструкции else if

В примере, рассмотренном выше, мы можем захотеть присвоить переменной x значе­ние 5, если условие x не выполняется (зачем оно нам, другой вопрос).

if (x else x = 5;

Если необходимо использовать несколько взаимоисключающих условий, их можно за­писать следующим образом:

if (условие1) команда1 else if (условие2) команда2 else if (условие3) команда3 ... else командаN

Упражнение 2

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

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

Составные команды

Несколько команд языка Java можно объединить в одну составную команду, используя фигурные скобки {}. Например, можно записать:

{ a = 12; letter = "D" ; }

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

if (x "S"; } else { x = 5; }

Конструкция из фигурных скобок называется также блоком команд , а фигурные скобки - границами блока .

Заметим, что используемая в примере форма записи (когда границы блока размещают­ся на отдельных строках, а содержимое блока записывается с отступом от его границ), не обязательна. Это просто правило стиля, позволяющее сделать программы более понятными и не запутаться в фигурных скобках, которые в программе на Java приходится использовать довольно часто.

об операторе выбора switch

Оператор выбора switch

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

switch (выражение) { case значение1: последовательность команд 1 break; case значение2: последовательность команд 2 break; ... default: последовательность команд по умолчанию }

Значение1, значение2 и т.д. - это константы или выражения, в которых участвуют только константы. Выражение в скобках после ключевого слова switch может содержать переменные. Это выражение вычисляется, а затем ищется соответствие результата с одним из значений после ключевого слова case . Если такое соответствие найдено, то выполняется вся последовательность команд, расположенная между двоеточием и ближайшей командой break . Если не найдено ни одного соответствия, выполнится последовательность команд по умолчанию, стоящая после ключевого слова default . Например:

char oper; // Знак операции, его выберет пользователь ... // Будем считать, что к этому моменту пользователь выбрал знак switch (oper) { case "+" : System.out.println(a + b); break; case "-" : System.out.println(a - b); break; case "*" : System.out.println(a * b); break; default: System.out.println("Неверный знак операции" ); }

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

Оператор цикла while

Цикл while имеет следующую форму:

while (условие) команда

Если условие в скобках (представляющее собой логическое выражение типа boolean ) истинно, будет выполнена команда - тело цикла (это может быть простая команда или по­следовательность команд в фигурных скобках), после чего программа снова вернется к вы­полнению этого оператора и будет повторять это до тех пор, пока условие не окажется ложным.

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

К примеру, следующий фрагмент программы выводит четные числа от 2 до 10:

int x = 2; while (x <= 10){ System.out.println(x); x += 2; }

о цикле while с постусловием

Существует другой вариант записи цикла while :

do команда while (условие)

При использовании этого варианта сначала выполняется команда, а потом проверяется условие. Оба варианта работают одинаково, но во втором случае тело цикла (команда) вы­полнится хотя бы один раз, даже если условие изначально ложно.

Упражнение 3

С помощью цикла while выведите все нечетные числа от 1 до 10.

Подсказка: немного измените алгоритм вывода четных чисел.

Оператор цикла for

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

for (команда инициализации; условие; команда перехода) тело_цикла

Перед началом цикла выполняется команда инициализации. Затем проверяется условие перехода (представляющее собой логическое выражение). Если это условие истинно, выпол­няется команда (или блок команд в фигурных скобках), составляющая тело цикла. Затем вы­полняется команда перехода и все начинается заново. Команда перехода обычно изменяет переменную, влияющую на истинность условия, а команда инициализации представляет собой описание этой переменной.

Обычно цикл for используется в следующем виде:

for (int i = 1; i <= 10; i++) тело_цикла;

В этом примере тело_цикла выполнится ровно 10 раз. При этом на каждой итерации будет доступна переменная i (она называется переменной цикла), последовательно пробегаю­щая значения от 1 до 10. Следующий фрагмент программы выводит четные числа от 2 до 10 (аналогично примеру цикла while):

for (int i = 1; i <= 5; i++) System.out.println(i*2);

Упражнение 4

С помощью цикла for выведите все нечетные числа от 1 до 10.

Операторы break и continue

Когда тело цикла (for или while ) состоит из нескольких команд, может возникнуть ситуация, что на очередной итерации выполнять их все нет необходимости. В этом случае полезными оказываются операторы break и continue .

Оператор break прекращает выполнение текущего цикла, независиом от того, выполняется ли условие его окончания.

Оператор continue прекращает выполнение текущей итерации цикла. То есть, если в теле цикла встречается этот оператор, то остальные, следующие за ним команды пропускаются и начинается новая итерация (повторение) цикла.

Заключение

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

Дополнительная литература

1. Вязовик Н.А. Программирование на Java. (главы 1 - 4, 7, 10)

2. Хабибуллин И.Ш. Самоучитель Java 2. (глава 1)

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

Страницы 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 для отсылки данных клиенту.