Введение

Дорогие ребята!

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

В первом модуле курса на вас обрушилось много новой информации, при этом вы смогли не только наблюдать, но и лично участвовать в процессе создания компьютерной игры. Вы поняли, что за написанием компьютерной игры стоит определенный труд, который требует навыков и опыта программирования. Если эти трудности не испугали вас, то вы уже добились определенного результата.Давайте еще раз вспомним известную фразу: "Программистами не рождаются –программистами становятся!" Как и в любом другом деле вы сможете добиться результата, только если будете прилагать усилия. Важное качество в изучении программирования –это умение не сдаваться!

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

Наблюдая и изучая построение разносторонних приложений, вы сможете глубоко проникнуть в суть разработки программного обеспечения. Вы увидите, что существует много принципиально общего в создании как компьютерных игр, так и любых других приложений. Язык Java позволяет вам создавать приложения любого характера,реализовать любые ваши идеи. При этом вы можете создавать эти приложения не только для операционной системы Windows, но и для Mac OSи Linux, что особенно приятно, с учетом их возрастающей популярности.

Занятие 1.Обработка событий, связанных с устройством управления "мышь"

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

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

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

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

· Клавиши мыши: правая клавиша мыши часто используется,чтобы открыть так называемое контекстное меню (это меню содержит основные, наиболее часто используемые команды).

· Клавиши мыши: средняя клавиша мыши иногда присутствует у данного устройства и имеет функционал,сходный с левой клавишей.

· Колесико прокрутки используется для быстрого просмотра страниц программы.

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

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

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

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

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

Работу сегодня, как и всегда, следует начать с создания нового проекта.

Вспомним!!!Чтобы открыть новый проект, необходимо открыть среду разработки Eclipse, выполнить команды: Файл "Создать" Проект Java, указать номер урока, в данном случае lesson13 и нажать на кнопку Готово. Появится папка под названием lesson13. Наведите на неё курсор мыши, нажав правую клавишу, выполните команду Создать Класс. Далее следует назвать будущую программу prog13, установить галочку public static void main.

У нас появляется заготовка программы, которая и будет использоваться в качестве файла для размещения программного кода. Обратите внимание: если у вас вдруг закрыто окно"Структура пакетов", которое отображается слева, его можно открыть из меню. Для этого в строке меню нужно будет выполнить следующую команду: "Окно" –"Показать панель"–"Структура пакетов". Окно вновь появится на экране (см.рис. 1.1):

Рис. 1.1

Появившиеся комментарии можно удалить. При помощи команды "Импорт", подключим библиотеки, которые понадобятся для создания приложения. Это библиотеки "javax.swing.*", "java.awt"и "java.awt.event.*;".

Вспомним!!!Библиотека «javax.swing.*» позволяет нам работать с окнами JFrame и позволяет создать окно нашего приложения. Библиотека «java.awt» позволяет работать с элементами окон и с элементами графики, которая воспроизводится внутри окна.Библиотека «java.awt.event» позволяет работать с обработчиками событий. Например, обработка событий мыши, клавиатуры, позволяет работать с таймером и др.

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

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

Создадим окно на основании класса, который будет описан чуть-чуть ниже. Назовем этот класс "okno".Переменная,соответствующая данному объекту будет иметь тип "window":

// Создание объекта окна

okno window = new okno();

Создадим класс под названием "okno" (под основным классом). Этот класс наследуется от класса JFrame. JFrame–это класс окон,которые используются в наших приложениях.Напомним, что наследование одного класса от другого определяется служебным словом"extends". У нас появился следующий участок программного кода:

//Класс окна

class okno extends JFrame

{

}

Теперь создадим конструктор класса. Напомним, что имя конструктора всегда совпадает с именем класса, а сам конструктор срабатывает при создании объекта. В этом конструкторе следует описать характеристики окна.Определим его расположение и размеры.Сделать это можно с помощью метода "setBounds". У данного метода существуют четыре параметра: первые два –это координаты расположения окна (верхней левой точки окна), следующие два - это ширина и высота окна. Таким образом, строка программного кода

setBounds(0,0,800,600);

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

При помощи метода "setTitle"можно указать заголовок окна –название, которое будет выводиться в верхней части. Наше окно можно будет назвать, например, "Управление приложением с помощью мыши". Получится следующая строка программного кода:

setTitle("Управление приложением с помощью мыши");

Если вы все сделали верно, то у вас на экране должен отображаться следующий программный код:

Добавим панель для нашего окна. Создадим еще один класс,объекты которого будут иметь тип переменной "panel". Класс будет описан ниже, а мы с вами продолжим описывать класс "okno", и создадим объект типа "panel". У нас получится следующая строка программного кода:

panel pan = new panel();

Теперь свяжем окно с панелью. Для этого создадим переменную типа "container",которая и позволит связать окно с панелью.При помощи метода getContentPaneможно получить содержимое окна JFrame, а при помощи метода addдобавить панель, "вложить" ее в окно:

Container con = getContentPane();

con.add(pan);

Создадим класс с названием "panel".Класс наследуется от классаJPanel–от класса панелей окна. И именно внутри класса JPanel будут реализованы те самые элементы графики, которые должны присутствовать в нашем графическом редакторе.

Запустим программу на исполнение. Пока никакого результата не видно, т.к. в конструкторе класса окна не хватает еще одного важного метода - setVisible, который позволит отобразить созданное нами окно.Добавив этот метод в класс окна, получим следующий программный код:

Перейдем к созданию инструментов рисования и палитры цветов нашего графического редактора.

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

Прежде всего, в классе"panel" добавим те переменные, которые будут использоваться внутри класса и понадобятся для реализации приложения.

Создадим массив, в котором будет храниться список цветов,использующихся в нашем приложении. Назовем массив "masColor".Массив будет типа "Color[]"(по англ. цвет). Напомним, что квадратные скобки говорят о том, что это массив:

// Массив цветов

Color[] masColor;

Теперь создадим переменную tCol,задав ей начальное значение 0.

В этой переменной будет храниться номер цвета, который выбрал пользователь:

// Переменная -отвечающая

// за текущий выбранный цвет

int tCol = 0;

Введем две переменные под названием mXи mY, в которых будут храниться координаты курсора мыши:

// Переменные для хранения

// координат мыши

int mX,mY;

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

Создадим переменную"flag" логического типа "boolean" (тоже "закрытую").Переменная будет принимать два значения:"true" ("истина"),если пользователь рисует, и "false"("ложь") –в противном случае.Присвоим ей начальное значение "false"("ложь"):

- mousePressed–срабатывает при нажатии на кнопку мыши;

- mouseReleased– срабатывает,если пользователь отпускает клавишу мыши;

- mouseEntered–срабатывает при появлении курсора на панели окна;

- mouseExited– срабатывает,если курсор выходит за пределы окна.

Во втором классеMouseMotionListeneесть два метода:

- mouseDragged- анализирует перемещение мыши при нажатой левой кнопке.

- mouseMoved-анализирует сам факт перемещения курсора мыши по экрану.

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

Строка

System.out.println;

позволяет вывести информацию в консольное окно. Консольное окно является для нас вспомогательным окном для анализа программы.

Если происходит событие,то вызывается нужный обработчик события (в зависимости от типа событий). В этом случае характеристики события передаются в его обработчик при помощи параметра типа"mouseEvent". Этот параметр носит имя "e". Через эту переменную можно получить характеристики данного события.

Если обратиться к переменной "e"и воспользоваться оператором".", можно увидеть список методов. Среди этих методов следует выбрать метод getX()- положение в пикселях от курсора мыши, то есть отступ его от левой части экрана. В этой же строчке следует поставить знак "+", прибавив к getX() несколько пробелов, заключенных в кавычки (в этом случае образуется отступ при выведении на экран, и смотреть будет удобнее). Теперь еще раз обратимся к переменной "e"и, снова воспользовавшись оператором "." ,выберем метод getY ()- отступ от верхней части экрана в пикселях:

// При перемещении мыши

public void mouseMoved(MouseEvent e)

{

// Вывод в консольное окно текущих координат

// курсора мыши X, Y

System.out.println(e.getX()+" "+e.getY());

}

Перед тем как запустить программу, следует открыть консольное окно, выполнив следующие команды: меню"Окно" > "Показать панель" > "Консоль"(см. рис. 1.2).

Рис. 1.2

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

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

// Подключаем обработчики для мыши к нашей панели окна

addMouseListener(new myMouse1());

addMouseMotionListener(new myMouse2());

NewMyMouse-1()– это создание объекта на основании класса MyMouse-1, который содержит внутри себя пять методов.

NewMyMouse-2()– это создание объекта на основании второго класса,который содержит внутри себя два метода.

Эти две строчки подключили обработчики событий к нашей панели внутри окна. Теперь можно их обрабатывать.

Есть еще одна важная деталь, которую нужно учесть при создании нашего графического редактора. При работе с компьютерными приложениями часто открыто несколько окон. Если вы нажимаете клавиши мыши или клавиатуры, то эти события передаются, как правило, в то окно,с которым вы в данный момент работаете.Остальные окна в этот момент являются неактивными. Активное окно в этом случае принимает события. Чтобы окно имело возможность принимать события, необходимо применить метод SetFocusable ()со значением "true"("истина"):

//Делаем окно активным

SetFocusable (true);

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

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

- черный (BLACK);

- зеленый (GREEN);

- синий (BLUE);

- красный (RED);

- желтый (YELLOW);

- белый (WHITE);

- оранжевый (ORANGE);

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

Вспомним!!!Массивом называется набор однотипных данных. Это сложная структура, представляющая собой несколько областей оперативной памяти, находящихся последовательно, друг за другом. Эти ячейки связаны в единое целое. Можно сказать, что массив – это группа пронумерованных переменных, каждая из которых имеет свой номер (индекс) массива. Нумерация начинается с нуля.Обращение к элементам массива происходит через его индексы, указанные в квадратные скобки. Создается новый массив с помощью конструктора new (с англ. «новый»). Например:a = new int[3]; //создан массив из 3-х элементов типа int a[0]=5;//создан элемент с индексом 0 и значением 5 a[1]=7; // создан элемент с индексом 1 и значением 7 a[2]=9; // создан элемент с индексом 2 и значением 9

Создадим массив под названием masColor,который будет состоять из семи элементов–объектов класса Color:

masColor = new Color[7];

Важно!!!Класс Color используется для того, чтобы задать цвет для объекта. У класса Color есть конструкторы, которые позволяют определить цвет. Например, Color(int r, int g, int b);Этот конструктор создает цвет, смешивая три цвета с заданной интенсивностью. Аббревиатура RGB происходит от заглавных букв английского алфавита имен трех цветов (красный, зеленый, синий). Значения интенсивности задаются для каждой составляющей в интервале от 0 до 255.Если вы не хотите определять свой цвет, вызывая конструктор Color(), то вы можете воспользоваться уже определенными значениями цветов. Это статические переменные класса Color. Например, Color.black, Color.white, Color.yellow, Color.cyan, Color.magenta, Color.orange, Color.pink и пр. – английские названия цветов.

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

// Создаем массив из семи элементов

masColor = new Color[7];

masColor[0] = Color.BLACK;

masColor[1] = Color.GREEN;

masColor[2] = Color.BLUE;

masColor[3] = Color.RED;

masColor[4] = Color.YELLOW;

masColor[5] = Color.WHITE;

masColor[6] = Color.ORANGE;

Для создания палитры можно воспользоваться уже знакомым нам циклом for.

Вспомним!!!Циклом называется алгоритм, в котором последовательность действий повторяется некоторое количество раз.Конструкция "цикл for" - описание одного из множества видов циклических алгоритмов. Данная конструкция используется в том случае, когда число повторений заранее известно. Количество повторений в цикле задается с помощью счетчика цикла, который обозначается буквой i. В целом, выглядит эта конструкция на языке Java следующим образом:for (int i=1; i<=a; i++) {Команды, которые необходимо выполнить а раз }for – служебное слово;i=1 – начальное значение счетчика цикла;i<=a - конечное значение счетчика цикла;i++ - увеличивает значение счетчика цикла на 1;в фигурных скобках перечисляются команды, которые необходимо повторить – это т. н. "тело цикла".

Приступим к созданию палитры цветов. Запишем служебное словоfor, а в круглых скобках укажем параметры счетчика цикла.Наши цветовые фрагменты будут иметь номера0, 1, 2, 3, 4, 5, 6.Следовательно, начальное значение нашего счетчика будет равно 0. А условие окончания повторений будет либо i<=6,либо i<7. Мы воспользуемся вторым вариантом. У нас должна получиться следующая конструкция:

// Рисуем семь прямоугольников

// в верхней части для выбора цвета

for (int i=0; i<7; i++)

{

}

Перейдем к написанию команд в теле цикла. У каждого нового прямоугольника цвет будет другим. Таким образом, мы будем менять цвет внутри цикла.Сделать это можно при помощи метода setColor()(в скобках в качестве параметра указывается нужный цвет). Цвет следует взять из массива цветов,который мы определяли выше. Цвет хранится в массиве, в ячейке с определенным индексом.Чтобы обратиться к тому или иному значению цвета, запишем наименование массива, а в квадратных скобках укажем нужный индекс.Мы должны обратиться к каждому цвету:сначала к значению цвета с индексом 0, потом1 и так далее до индекса 6. Счетчик нашего цикла принимает значения от 0 до 6, поэтому в теле цикла запишем команду:

// Устанавливаем цвет рисования

gr.setColor(masColor[i]);

Цвет установлен, теперь нарисуем прямоугольник этого цвета.

Для рисования прямоугольника воспользуемся методомfillRect (a,b,c,d),который имеет четыре параметра:

a,b –координаты верхней левой точки прямоугольной области.

с –ширина прямоугольной области.

d –высота прямоугольной области.

Предположим, что все цвета палитры будут располагаться в верхнем левом углу друг за другом. Таким образом, параметр b=0. Пусть каждый следующий прямоугольник смещается в правую сторону от предыдущего на 100 пикселей, тогда значение параметра а будетравнымi*100. Т.к. i–счетчик цикла, и его значение меняется, то параметрaбудет принимать значения: 0, 100, 200, 300, 400, 500 и 600.Ширину прямоугольной области можно сделать равной 100пикселей, высоту 50пикселей, тогдас=100, d=50 и команда для рисования прямоугольника в теле цикла будет следующей:

// Рисуем закрашенный прямоугольник

gr.fillRect(i*100, 0, 100, 50);

В результате действий цикла палитра цветов будет иметь следующий вид (см рис. 1.3):