содержание   вперед   назад

5. Второй класс

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

class MainForm extends JFrame implements ActionListener { static JDesktopPane deskt; int i,j,k,km,l,lm,nt; String fn,ls; JMenu menu; JMenuItem submenu; String[] name; int[] mne; int[] acc; String[] act; String[] actt = new String[200];

Разберем, что означает написанное. Слово extends (развивает) означает, что наш класс является потомком класса JFrame. Кроме того, он наследует все методы абстрактного класса ActionListener. Это фактически не класс, а интерфейс как в фортране или С -- он только декларирует список методов. В данном случае наш интерфейс, как следует из его названия, определяет реакцию на действия пользователя, например, выбор иконки в меню.

Далее, мы декларировали статический объект класса JDesktopPane. Этот класс определяет внешнюю панель нашего окна, в которую мы будем помещать внутренние окна. Внутренние окна, также как и диалоги, не имеют своих иконок -- они закрываются и открываются вместе с главным окном. Это удобно, так как окна нашей программы на экране не будут путаться с окнами других программ. Почему надо объявить объект статическим. Потому что он у нас фактически один, но нам может понадобиться обращаться к нему из других классов. Мы будем делать это таким образом -- открывать новый объект класса MainForm и возвращать из него только deskt. Так как он статический -- мы не промахнемся и попадем точно в наше окно. Это станет ясно позднее. Пока просто запомните эти слова. Все остальные типы переменных нам знакомы кроме JMenu и JMenuItem. Но они очевидны и мы ими скоро займемся. Хочу отметить, что все объекты только продекларированы, в то время как массив строк actt уже определен более точно, так как указан его размер.

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

Как я уже предупреждал, мы задаем пустой конструктор. Так надо, иначе при получении deskt в других классах мы будем делать лишнюю работу. Следующий метод make() мы уже использовали. Теперь мы будем его определять

public void make() throws IOException { fn="icon.png"; BufferedImage bi = javax.imageio.ImageIO.read(new File(fn)); setIconImage(bi);

Первая строка ясная. Метод public так как мы его использовали в другом классе. Обработка ошибок та же. Следующие строчки задают иконку в левый верхний угол нашего окна. Предполагается, что иконка нарисована в файле с названием icon.png. При работе программы этот файл должен присутствовать в папке программы, иначе будет ошибка. Класс BufferedImage очень важный и интересный класс. Его объект bi содержит нашу картинку в развернутом виде матрицы пикселей. При этом статический метод read() класса javax.imageio.ImageIO прочитывает файл с нашим именем и автоматически декодирует картинку в матрицу пикселей. Чтобы не было конфликтов с методами read() других классов здесь надо полностью указывать весь путь к классу. Далее, класс JFrame имеет функцию (метод) setIconImage(), которая устанавливает эту картинку в качестве иконки окна. Очень важно знать какие типы (классы) какая функция имеет в виде аргументов, иначе получится ошибка и компилятор код забракует. Если указанный код не поставить, то ничего страшного не произойдет. Виртуальная машина сама поставит иконку по умолчанию в виде чашки кофе.

Далее

Эта функция класса JFrame устанавливает имя окна (title). Строку с именем мы уже определили раньше, а теперь используем, и она нам еще не раз понадобится. Двигаемся дальше, пишем

Dimension scrSize = Toolkit.getDefaultToolkit().getScreenSize(); km=scrSize.width; lm=scrSize.height-25; ls=MyPro.readLine("First.ini",2); act = MyPro.split(ls,'|'); i=Integer.parseInt(act[0]); j=Integer.parseInt(act[1]); k=Integer.parseInt(act[2]); l=Integer.parseInt(act[3]); i += (km-k)/2; j += (lm-l)/2; if(i < 0){i=0;} if(j < 0){j=0;} if(i > km-k){i=km-k;} if(j > lm-l){j=lm-l;} setBounds(i,j,k,l);

Этот довольно большой кусок текста определяет размеры окна и его положение на экране. Это можно делать разными способами. Рассмотрим сначала то, что написано. Первая строка определяет размеры экрана дисплея в пикселах. Здесь указаны два метода, последовательно выполняемые слева направо. Первый статический метод класса Toolkit возвращает новый объект класса Toolkit, а второй метод уже принадлежит этому объекту. Но нам это даже не обязательно разбирать. Размеры экрана дисплея возвращаются именно такой строкой и именно в объект класса Dimension. Затем мы вынимаем ширину и высоту этого объекта в пикселах в целые переменные km и lm. Потом считываем четыре числа из второй строки нашего файла с именем First.ini. Предполагается, что эти числа записаны с разделителем в виде символа вертикальной черты '|' (ASCII код 124). Сначала мы конкретизируем объект ls класса String, заполняя его второй строкой из нашего файла. Затем, используя статический метод split() нашего класса MyPro, разделяем одну строку в массив строк, тем самым уточняя объект act. В нашем случае индексы этого массива равны 0,1,2,3.

Далее мы видим, что переменные типа целый тоже имеют свой класс Integer и у этого класса есть статический метод parseInt(), который превращает строку в целое число, которое последняя описывает. Применяя этот метод 4 раза получаем нужные нам 4 числа i,j,k,l. Пусть первые два числа задают сдвиг центра нашего окна из центра экрана, а последние два числа задают размеры окна (все в пикселах). Тогда сдвиг центра нужно пересчитать в сдвиг левого верхнего угла, что и делается. Окончательно метод setBounds() класса JFrame задает размеры и положение окна на экране. Отмечу, что вместо него также можно использовать методы setSize(k,l) и setLocation(i,j) для раздельного задания размеров и положения окна. Если использовать метод setLocationRelativeTo(null), то окно автоматически устанавливается в центре экрана. То есть если лень много писать, то весь указанный выше код можно заменить на последнюю функцию и окно всегда будет в центре экрана.

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

deskt = new JDesktopPane(); setContentPane(deskt); deskt.setDragMode(JDesktopPane.OUTLINE_DRAG_MODE); setJMenuBar(createMenuBar()); }

Здесь мы наконец определили нашу главную панель deskt и затем поместили ее в окно методом setContentPane(). Затем мы установили новое свойство нашего окна. А именно, как его перерисовывать при перемещении по экрану. Мы установили, что при перемещении двигается только контур окна и только в конце перерисовывается все окно. Так быстрее и проще работает компьютер. Наконец, функцией setJMenuBar() мы поставили полоску меню в наше окно, но аргументом является не сама эта полоска -- объект класса JMenuBar, а функция (метод), которая эту полоску возвращает. Это стандартная практика в Java. Эту последнюю функцию нам как раз предстоит определить. А пока нас можно поздравить с завершением первой функции make().

Итак начнем определять меню нашего окна. Опять вспомним, что все параметры окна мы считываем из файла "First.ini". Пусть в третьей строке этого файла будет набито число разных разделов меню. А дальше на каждый раздел будет по одной строке, в которой сначала будет набито имя этого раздела, затем через пробел (или несколько пробелов) его код, затем через пробел будут заданы имена всех подразделов данного раздела, разделенные символом '|', затем через пробел будет задана последовательность мнемонических кодов клавиш (снова разделенные символом '|') и затем через пробел последовательность кодов клавиш ускорителей (снова с '|'). Чтобы было понятнее покажу как это должно выглядеть

4 Prog 80 Open|Exit 79|69 48|49 Show 75 Picture|Figure|Image 80|70|73 50|51|52 Run 82 Palit|Editor|Calculator 80|69|67 53|54|55 Help 72 About|Web|File 65|87|70 56|57|48

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

Клавиши, которые предпочтительно использовать

[0] = 48 [5] = 53 [A] = 65 [F] = 70 [K] = 75 [P] = 80 [U] = 85 [Z] = 90 [1] = 49 [6] = 54 [B] = 66 [G] = 71 [L] = 76 [Q] = 81 [V] = 86 [F1] = 112 [2] = 50 [7] = 55 [C] = 67 [H] = 72 [M] = 77 [R] = 82 [W] = 87 [F2] = 113 [3] = 51 [8] = 56 [D] = 68 [I] = 73 [N] = 78 [S] = 83 [X] = 88 и так далее [4] = 52 [9] = 57 [E] = 69 [J] = 74 [O] = 79 [T] = 84 [Y] = 89 [F9] = 120

Клавиши, которые лучше не использовать, но если очень надо, то можно

[BackSp] = 8 [Tab] = 9 [Enter] = 10 [Shift] = 16 [Ctrl] = 17 [Alt] = 18 [CapsLock] = 20 [Esc] = 27 [Space] = 32 [PageUp] = 33 [PageDn] = 34 [End] = 35 [Home] = 36 [LeftArr] = 37 [UpArr] = 38 [RightArr] = 39 [DownArr] = 40 [,] = 44 [-] = 45 [.] = 46 [/] = 47 [;] = 59 [=] = 61 [[] = 91 []]=93 [\] = 92 [Insert] = 155 [Delete]=127

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

protected JMenuBar createMenuBar() { JMenuBar menub = new JMenuBar(); StringTokenizer t; String mname; int ik,im,isb,nl,nm,nsb;

Здесь мы определили переменные и задали объект menub, который мы будем возвращать. Тип функции protected просто означает, что в процессе работы программы результат, выдаваемый этой функцией, нельзя изменять ни при каких условиях

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

определили число разделов меню. Метод nextToken() как раз возвращает очередную порцию текста без пробелов. Далее,

for(im=0; im < nm; im++){ nl++; ls=MyPro.readLine("First.ini",nl); t = new StringTokenizer(ls); mname=t.nextToken(); ik=Integer.parseInt(t.nextToken()); menu = new JMenu(mname); menu.setMnemonic(ik);

В цикле по разделам меню сначала считываем из файла очередную строку, вводим ее в разделитель текста и берем первый кусок. Это имя раздела. Берем второй кусок и преобразуем в число. Определяем объект класса JMenu с данным именем и данным мнемоническим кодом.

Берем следующий кусок и расщепляем его в массив строк name. Это объект класса String[]. Он описан в самом начале класса.

Поле (переменная) length у любого массива возвращает его размер. Поэтому nsb равно числу элементов массива name. Используя это число определяем размер целых массивов mne и acc, то есть фактически определяем массивы.

ls=t.nextToken(); act = MyPro.split(ls,'|'); for(isb=0; isb < nsb; isb++){mne[isb]=Integer.parseInt(act[isb]);} ls=t.nextToken(); act = MyPro.split(ls,'|'); for(isb=0; isb < nsb; isb++){acc[isb]=Integer.parseInt(act[isb]); act[isb]="ac"+nt; actt[nt]=act[isb]; nt++;}

Здесь мы два раза переопределили массив act и вынули из него целые числа -- коды клавиш. Но нам еще необходимо задать уникальное имя команды для каждого подраздела меню. Проще всего автоматически сгенерировать эти имена, используя порядковый номер подраздела, что и было сделано. В конце концов массив act[] равен строкам, у которых два первых знака равны ac, а следующие -- текстовому представлению переменной nt. Здесь полезно отметить, что строки можно соединять при помощи знака + и даже соединять с числами, при этом числа автоматически преобразуются в текст. Кроме того, надо собрать весь набор команд в массиве actt[]. Далее,

createSubMenu(); menub.add(menu); }

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

menu = new JMenu("About"); menu.setMnemonic(KeyEvent.VK_A); name = new String[]{"About Program","About Author"}; mne = new int[]{KeyEvent.VK_P, KeyEvent.VK_A}; acc = new int[]{KeyEvent.VK_F1, KeyEvent.VK_F2}; act = new String[]{"pppp", "llll"}; createSubMenu(); menub.add(menu); return menub; }

Здесь используется еще одна тонкость Java -- объявляется массив и тут же он определяется в фигурных скобках перечислением. Вот теперь вся полоса меню задана. А мы полностью написали вторую функцию. Но она использует новую функцию (метод) createSubMenu(). Этот метод имеет абсолютно стандартный вид и вы можете ставить его в каждую свою программу не задумываясь. Я даже не буду его комментировать, а просто приведу код

protected void createSubMenu(){ for( i=0; i < act.length; i++ ){ submenu = new JMenuItem(name[i]); submenu.setMnemonic(mne[i]); submenu.setAccelerator(KeyStroke.getKeyStroke(acc[i], ActionEvent.ALT_MASK)); submenu.setActionCommand(act[i]); submenu.addActionListener(this); menu.add(submenu); }}

Обратите внимание, что этот метод ничего не возвращает и оперирует общими переменными класса. Я уже говорил, что клавиши акселераторов подразделов меню надо будет нажимать одновременно с клавишей [Alt]. Эта вторая клавиша определена в виде переменной ActionEvent.ALT_MASK. Так длинно и сложно пишутся числа-константы в Java. Сделано это для того, чтобы было удобно читать код. А до этого были написаны числа, определяющие коды клавиш как KeyEvent.VK_F1 (клавиша [F1]).

Замечу также, что можно было бы написать чуть более сложный код, и в явном виде (через файл First.ini) указать полную комбинацию клавиш, то есть вместо [Alt] можно было бы альтернативно использовать [Ctrl] или даже обе клавиши [Alt] и [Crtl] одновременно с основной клавишей. Такая ситуация может понадобиться для очень сложных программ, имеющих очень много подразделов меню. Далее, иногда необходимо, чтобы подразделы меню имели свои подразделы, то есть меню имело структуру дерева с многими поколениями веток. Это тоже возможно, просто соответствуюший подраздел меню надо задавать не объектом класса JMenuItem, а снова объектом класса JMenu и для него создать свою структуру разделов подразделов меню. Необходимость в этом тоже возникает для достаточно сложных программ.

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

public void actionPerformed(ActionEvent e){ for(i=0; i < nt; i++){ if( actt[i].equals(e.getActionCommand()) ){MyPro.isn=i+1; execPro();} } if( "pppp".equals(e.getActionCommand()) ){addAbout(1);} if( "llll".equals(e.getActionCommand()) ){addAbout(2);} }

Теперь понятно почему мы аккумулировали все коды команд в одном массиве actt[] заданной длины 200. Размер массива задан как бы с запасом, так как мы не знаем его истинного размера до самого конца прочтения файла First.ini, а у нас есть необходимость использовать его раньше, просто так код проще пишется. Как это работает? При выборе какого-либо раздела меню сгенерируется событие как объект класса ActionEvent и оно будет передано автоматически в нашу функцию actionPerformed(). Метод e.getActionCommand() возвращает код команды для данного события. Мы должны сравнить все наши коды команд с кодом данной команды, и при совпадении мы получаем номер раздела меню в переменную i. Удобно зафиксировать этот номер в статической переменной isn нашего класса MyPro, поскольку мы пока не знаем, где и когда будем использовать этот номер, и вызвать стандартную функцию execPro(). Ну и по ходу я изменил начальный номер в порядок счета номеров, вместо нуля сделал единицу. Фактически можно было бы функцию написать прямо здесь, не вводя новое обозначение, но это неудобно читать.

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

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

private void execPro(){ Thread tr = new Thread(new runPro()); tr.start(); }

Из этого текста видно, что весь код нашей программы мы теперь будем писать в классе runPro, который обязан поддерживать интерфейс Runnable, так как его объект является аргументом объекта класса Thread. При этом мы будем использовать переменную MyPro.isn. То есть нам в том классе придется сделать ветвление и обрабатывать каждое значение этой переменной. Осталось написать функцию addAbout(). В простейшей форме она просто сообщает некий текст в специальном окне. Тогда ее код может быть таким.

private void addAbout(int n){ String mess; mess=" "; switch(n){ case 1: mess = "\n Первое сообщение "+ "\n текст второй строки "+ "\n и так далее "+ "\n "; break; case 2: mess = "\n Второе сообщение "+ "\n текст второй строки "+ "\n и так далее "+ "\n "; break; } JOptionPane.showMessageDialog(this, mess, "About", JOptionPane.INFORMATION_MESSAGE); }

Статический метод showMessageDialog() класса JOptionPane -- это полностью готовая программа, которая показывает текст в отдельном окне в режиме диалога, то есть программа ждет и ничего не делает, пока пользователь не нажмет клавишу "OK".

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

public JDesktopPane getDesktop(){ return deskt; } }

Теперь мы закончили написание кода для второго класса, но чтобы закончить программу, нам осталось написать еще два класса MyPro и runPro. Это мы будем делать в других файлах. А этот файл написан и пора подумать о импорте пакетов Java, которые мы использовали. Мы должны добавить указатели на эти пакеты в начале файла. Самый простой способ -- пустить файл на компиляцию и компилятор вам сам скажет каких классов он не нашел. Затем надо посмотреть в каких они пакетах и добавить. Я как раз так и собираюсь проделать. Компилятор не нашел следующих классов

Класс Пакет Action Event java.awt.event.* Action Listener java.awt.event.* BufferedImage java.awt.image.* Dimension java.awt.* IOException java.io.* JDesktopPan javax.swing.* JFrame javax.swing.* JMenu javax.swing.* JMenuBar javax.swing.* JMenuItem javax.swing.* JOptionPane javax.swing.* KeyEvent java.awt.event.* KeyStroke javax.swing.* StringTokenizer       java.util.* SwingUtilities javax.swing.* Toolkit java.awt.* UIManager javax.swing.*

Классы, входящие в пакет java.lang.* компилятор нашел, например String. Этот пакет считается основой языка Java и компилятор в нем ищет классы в любой программе автоматически. Все найденные классы имеются в версиях 1.2.2 и выше. Но используемый в явном виде класс javax.imageio.ImageIO появился позднее версии 1.2.2.

Итак, нам необходимо в начало файла поставить следующие строки

import java.awt.*; import java.awt.event.*; import java.awt.image.*; import java.io.*; import javax.swing.*; import java.util.*;

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

содержание   вперед   назад

---

.