Занятие 2.Проектирование интерфейса пользователя

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

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

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

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

Создадим новый проект обычным образом.

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

Весь процесс добавления элементов на форму условно можно разбить на следующие шаги:

Шаг 1:

Создается переменная определенного типа (в зависимости от выбранного элемента "кнопка", "переключатель", "список" и др.).

Шаг 2:

Задаются свойства элемента (ширина, высота, цвет текста надписи, шрифт и др.).

Шаг 3:

Подключаются обработчики событий.

Шаг 4:

Созданный элемент отображается на панели, размещенной внутри оконной формы JFrame.

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

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

Нам понадобятся в очередной раз три библиотеки: javax.swing.*, Java. awt.* и java.awt.event.*, которые позволят работать с оконными формами, с элементами интерфейса пользователя, с элементами графики,обработчиками событий и др.

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

Внутри метода mainсоздадим новый объект – окно.Новая переменная будет иметь тип "okno":

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

okno nf = new okno();

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

Теперь можно перейти к созданию нового класса. Класс будет называться "okno"и наследоваться от класса JFrame. Напомним, что если класс наследуется от класса JFrame, он сразу же получает весь функционал, который есть в классе JFrame.Следовательно, объекты нового класса будут являться окнами:

// Создаем класс окна,наследуется от класса JFrame

class okno extends JFrame

{

}

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

// Устанавливаем расположение и размеры окна

setBounds(0, 0, 800, 600);

Первые два параметра команды setBounds–это координаты его верхней левой угловой точки. Мы поставили значение 0,0.Следовательно,верхний левый угол окна будет размещаться четко по левому верхнему углу экрана.Третий параметр (600пикс.) –это ширина окна, а последний, четвертый параметр (500пикс.) – высота окна.

Можно установить заголовок окна, воспользовавшись методомsetTitle:

//Устанавливаем заголовок окна

setTitle ("Калькулятор");

Чтобы форма окна отображалась на экране, воспользуемся методом setVisibleсо значением "true" ("истина"):

// Показываем(отображаем) окно

setVisible(true);

В целом, программный код будет выглядеть так:

Можно запустить программу на исполнение. Если ошибок в программном коде нет, то на экране появится окно с названием "Калькулятор", шириной 600пикс., высотой 500 пикс., а его верхний левый угол четко совпадет с углом экрана, т. е. без отступов сверху и слева.

Теперь свяжем панель типа JPanelи оконную форму. Для этого в самом начале конструктора класса окна создадим переменную contтипа "container". При помощи метода getContentPaneможно получить в эту переменную контент окна. Контент окна –это его содержимое.Переменная типа "container"позволяет вложить панель JPanelв нашу оконную форму JFrame:

// Создаем переменную для достпуа к содержимому окна

Container cont = getContentPane();

Теперь создадим переменную panтипа JPanel –это и есть наша панель:

//Создаем панель для окна

JPanel pan = new JPanel();

Обратимся к переменнойcont, чтобы при помощи метода addдобавить панель к нашему окну:

// Прикрепляем панель к окну

cont.add(pan);

Запустим приложение на исполнение, но никаких визуальных изменений не увидим.

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

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

- кнопки, которые отображают все цифры от 0 до 9;

- кнопки, которые отображают арифметические операции ("+", "-", "*", "/");

- кнопка "Равно";

- кнопка "Очистить поле";

- кнопка "Выход";

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

Наш будущий калькулятор будет выглядеть примерно так (см. рис.2.1):

Рис.2.1

Создадим в классе "okno"несколько переменных, которые будут использоваться внутри нашего класса. Первая переменнаяtextбудет закрытой, т.е. доступной только внутри класса и иметь тип JTextArea (текстовое поле, в которое пользователь может ввести какой-то текст).

// Текстовое поле для результата

private JTextArea text;

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

Создадим две переменные типа "double",которые будут хранить результаты для арифметических операций. Арифметические операции у нас будут проводиться с двумя числами. Переменная р1будет хранить первое число, а переменная p2будет хранить второе число (это те числа,которые будет вводить пользователь):

//Две переменные для хранения двух введенных чисел

private double p1=0,p2=0;

Предположим, что каждая наша арифметическая операция будет соответствовать определенной цифре.Например:

сложение – 1;

вычитание – 2;

умножение – 3;

деление – 4;

Номер арифметической операции будет хранить переменная oper. Эта переменная будет являться переменной целого типа с начальным значением 0. Когда пользователь будет нажимать на кнопку операции, значение переменнойoperбудет принимать значение 1, 2, 3 или 4:

//Тип операции,выбранной пользователем

private int oper=0;

А теперь приступим к реализации интерфейса пользователя.Предположим, что на панель можно добавлять элементы формы в произвольном размещении,т.е. можно указывать их отступы от краев формы в произвольном виде. Такая настройка напоминает размещение тэгов наhtml-странице. Для создания настройки воспользуемся методом setLayoutсо значением"null":

//Включаем возможность произвольного размещения

//всех элементов формы(кнопок, текстовых полей и т.д.)

pan.setLayout(null);

Можно также добавить несколько различных шрифтов для кнопок,надписей и текстового поля. Чтобы задать шрифт, нам нужно создать переменную типа"font"и указать конкретные характеристики шрифта.Создадим новый объект с именем переменнойbtnFontи с типом"font":

setSize (a,b)позволяет указать ширину и высоту. В скобках указываются значения параметров: a–ширина кнопки, b –высота кнопки.

setFont (c) позволяет указать шрифт, который будет использоваться для отображения надписи на этой кнопке. В скобках указывается нужный шрифт.

setLocation (a,b)позволяет указать отступы ее верхней угловой точки от верхней угловой точки панели.

Мы создадим кнопку со следующими значениями параметров:

// Создаем кнопку

btn[i] = new JButton();

// Устанавливаем размер

btn[i].setSize(100, 25);

// Устанавливаем шрифт

btn[i].setFont(btnFont);

// Устанавливаем ее расположение

btn[i].setLocation(100, 100);

Добавим кнопку к панелиJPanel при помощи метода add:

pan.add(btn)

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

Запустим приложение на исполнение. Мы увидим кнопку,расположенную на панели окна приложения(см. рис. 2.2):

Рис. 2.2

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

- текстовое представление, например, текстовое представление кнопки – это та надпись, которая указывается на ней;

- размеры–ширина и высота;

- шрифт–используется для вывода текстовых надписей;

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

Нам понадобится семнадцать кнопок, поэтому для удобства лучше все кнопки поместить в массив.Поэтому блок, в котором мы описали процесс создания кнопки:

нужно удалить, и перейти к созданию массива кнопок:

JButton[] btn = new JButton[17];

btn–имя массива кнопок.Напомним, что квадратные скобки говорят о том, что мы создали массив. JButton–тип элементов массива. В правой части в квадратных скобках указывается количество элементов в массиве. Теперь нужно добавить в массив сами элементы. Добавлять элементы будем с помощью цикла for. В цикле зададим характеристики для всех кнопок, которые будут присутствовать в массиве. Так как нумерация элементов массива начинается с нуля, переменной целого типа под названием i (счетчик цикла)присвоим начальное значение 0. Кроме того, элементов в нашем массиве должно быть 17. Следовательно нужно указать условие: пока i<17; i++. Данное условие означает, что переменная iбудет увеличиваться на единицу на каждом шаге цикла. Таким образом, переменные будут принимать значения 0,1,2...16:

btnFont–это тот шрифт, который мы определили выше.

При помощи методаsetLocationнужно указать координаты размещения кнопки на панели:

// Устанавливаем ее расположение

btn[i].setLocation(30, 50 + i*30);

Значение 30–это отступ в пикселях от левой части панели. Значение второго параметра записано в виде формулы:50 + i ? 30. Таким образом, отступ от верхней части панели для каждой кнопки будет каждый раз увеличиваться на 30пикс., и получится так, что каждая последующая кнопка будет находиться ниже, чем предыдущая кнопка.

Добавляем кнопку к панели:

//Прикрепляем кнопку к панели

pan.add(btn[i]);

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

Можно запустить наше приложение. На экране должно появится окно под названием "Калькулятор". На панели окна располагаются 17 кнопок одинакового размера (см. рис. 2.3):

Рис. 2.3

Так как кнопок довольно много, то все они могут не поместиться на форму. В этом случае размер окна можно увеличить, изменив значение последнего параметра в методе setBounds():

// Устанаваливаем расположение и размеры окна

setBounds(0, 0, 800, 600);

Чтобы кнопка работала,ее не достаточно просто отобразить на экране. К ней нужно добавить обработчик события. Добавлять обработчик мы будем к каждой из 17-ти кнопок. Поэтому в циклеfor, с помощью которого мы добавляли кнопки, перед тем,как прикрепить кнопку к панели, нужно добавить следующие строки:

// Подключаем обработчик события

btn[i].addActionListener(new ActionListener()

{

// Метод, который выполняется при нажатии кнопки

public void actionPerformed(ActionEvent e){

// Вызов метода для обработки нажатия клавиш

btnClick((JButton)e.getSource());

}});

Таким образом, мы обращаемся к очередному элементу массива и вызываем метод addActionListener().В круглых скобках метода addActionListenerзапишем"new ActionListener".

Если вы начнете записывать название этого метода: new Action, - и нажмете комбинацию клавиш Ctrl+"Пробел", то у вас открывается окно подсветки. В этом окне вы найдете единственный метод –ActionListener. При нажатии на клавишу Enterсреда разработки автоматически вставляет его содержание: newActionListener–это новый класс, actionPerformed–метод,который появился внутри этого класса.

При помощи методаActionListenerмы подключили обработчик события ко всем кнопкам, которые находятся на форме. МетодactionPerformed –это метод, который срабатывает при нажатии на кнопку.

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

JOptionPane.showMessageDialog (null, "Привет!");

Внутри метода showMessageDialogуказаны два параметра. Первый параметр –так называемое"родительское окно"данного диалогового окна, а второй параметр – это то сообщение, которое будет выводиться при нажатии на кнопку. Родительского окна у нас нет, поэтому в качестве первого параметра указываем значение "null"(пустой параметр, пустое значение). Можно запустить программу на исполнение и попробовать нажать на одну из кнопок. На экране должно появиться диалоговое окно, в котором выведено сообщение –"Привет!" (см. рис. 2.4):

.

Рис. 2.4

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

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

В параметр этого метода(в круглых скобках) передадим ту кнопку,которая нажата в текущий момент. При помощи переменной типа ActionEvent, находящуюся в круглых скобках метода actionPerformed,можно получить характеристики события,произошедшего в текущий момент. Например,обратившись к этой переменной через оператор ".", при помощи метода getSource()можно получить ту кнопку, которая сейчас нажата. Запишем следующую команду:

//Вызов метода для обработки нажатия клавиш

btnClick((JButton)e.getSource());

В круглых скобках мы указали тип JButton. Это так называемое явное приведение типа переменной к типу JButton, то есть к типу "кнопка".

Теперь создадим непосредственно сам метод btnClick().Он будет располагаться над конструктором класса,под объявлением переменных класса. Этот метод будет закрытым, поэтому записываем слово private("закрытый"). Поскольку этот метод не возвращает значение, нужно указать слово void:

// Метод для обработки нажатия клавиш

private void btnClick(JButton btn)

{

}

В круглых скобках мы указали переменную типаJButtonс именемbtn.Внутреннюю часть метода пока не записываем. Но следует понимать, что этот метод будет каждый раз вызываться при срабатывании одной из кнопок. И для того чтобы это продемонстрировать, можно уже внутри метода btnClick()записать тот же самый метод вызова диалогового окна с двумя параметрами:родительское окно (значение null) и сообщение:

JOptionPane.showMessageDialog (null, "Кнопка нажата!");

Если вы попробуете запустить приложение на исполнение, то при нажатии на кнопку появится диалоговое окно с сообщением "Кнопка нажата!" (см. рис. 2.5):

Рис. 2.5

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

Возвратимся к реализации интерфейса. Теперь нам нужно,чтобы на кнопках, которые отображаются на форме, выводились определенные надписи–цифры от 0 до9, знаки арифметических операции и др.Начнем с указания цифр.

Создадим еще один цикл со счетчиком i.Условие работы цикла: пока i< 10, значение счетчика увеличивается на 1. Внутри цикла записываем следующую команду: обращаемся к массиву btn, в квадратных скобках указав счетчик i, и вызываем методsetText().Внутри метода setTextзаписываем следующую конструкцию: ""+i (""–пустая строка, то есть строка, в которой нет символов). Такая форма записи нужна для того, чтобы числовую переменную целого типа, которой является у нас счетчик, перевести в строковый тип.Дело в том, что метод setTextтребует, чтобы в его круглых скобках была указана переменная типа "string"(строка). Таким образом, наш цикл примет следующий вид:

for (int i=0;i<10;i++) btn[i].setText(""+i);

Программный код должен выглядеть так:

Запустите программу на исполнение –первые десять кнопок должны получить свои наименования –цифры от 0 до 9.

Рис. 2.6

В данном случае цикл использовался для того, чтобы задать наименования кнопок в автоматическом режиме. Но, к сожалению, такая операция автоматически не может быть выполнена к другим кнопкам, потому что их названия уже не поддаются какой-то закономерности. У нас с вами остались кнопки, т.е. элементы массива кнопок, с номерами 10, 11, 12, 13, 14, 15, 16.Обратимся к каждой из оставшихся кнопок по ее номеру и укажем с помощью метода setText() их названия: "+", "-", "/", "*", "=", "С", "Выход". Таким образом, мы получим следующие строчки:

btn[10].setText("+");

btn[11].setText("-");

btn[12].setText("/");

btn[13].setText("*");

btn[14].setText("=");

btn[15].setText("C");

btn[16].setText("Выход");

Запустим вновь программу на исполнение –все кнопки получили свои наименования (см. рис. 2.7):

Рис. 2.7

Переходим к размещению на форме окна текстовой надписи. Текстовая надпись JLabel–надпись,которая выводится на форму. Нам нужно создать переменную типа JLabelпод названиемlebи новый объект типа JLabel.В круглых скобках записываются символы,которые нужно вывести. Мы выведем надпись: "Результат: ":

// Создаем текстовую надпись

JLabel lab = new JLabel("Результат: ");

После создания самого объекта можно указать его свойства:

- шрифт. Воспользуемся шрифтом Lebfont,который был определен выше:

// Устанавливаем шрифт

lab.setFont(labFont);

- отступы от левой верхней части экрана, ширина и высота области, в которой будет находиться надпись. Зададим эти параметры при помощи метода setDown():

// Устанавливаем размеры

lab.setBounds(130, 0, 300, 50);

130 и 0– это отступы от левой и верхней части экрана, 300–ширина области, в которой будет располагаться надпись,50– высота этой области.

После указания характеристик, текстовую надпись следует прикрепить к панели при помощи методаadd:

// Прикрепляем надпись к панели

pan.add(lab);

Запустите программу на исполнение –на форме окна приложения должна появиться надпись "Результат: " (см. рис. 2.8):

Рис. 2.8

Теперь нам осталось определить текстовое поле для вывода результата. Для создания такого поля будем использовать переменную с названиемtext. Это переменная типа "текстовое поле", которая определена в самом вверху класса.Поскольку переменная уже определена, можно записать ее имя и создать новый объект:

//Создаем текстовое поле

text = new JTextArea();

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

- шрифт. Вновь воспользуемся шрифтом, который определили выше –Text Font:

//Устанавливаем шрифт

text.setFont(textFont);

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

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

text.setBounds(300, 10, 300, 35);

- цвет текста, который будет вводиться в это поле. Цвет текста можно указать при помощи метода setForground().Создадим новый объект под названием Color (с помощью методаnew), с указанием параметров R, G, B.Это три составляющих цвета,соответственно, R("red")–красный, G("green") –зеленый и B("blue")–синий. Все три составляющие могут принимать значения от0до 255. Если значение GиBравно 0, а значение B числу, то мы получим синий цвет определенного оттенка, например:

// Устанавливаем цвет текста ТЕМНО-СИНИЙ

text.setForeground(new Color(0,0,100));

- цвет фона текстового поля. Выберем в качестве фонового цвета белый цвет. Его можно задать при помощи метода setBackground()и перечисления Color:

// Устанавливаем фон текстового поля - БЕЛЫЙ

text.setBackground(Color.WHITE);

После указания свойств,текстовое поле следует прикрепить к окну при помощи метода add:

// Прикрепляем текстовое поле к панели

pan.add(text);

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

Запустим программу на исполнение –на форме окна появилось текстовое поле (см.рис. 2.9):

Рис. 2.9

В текстовое поле можно вводить текст. Если вы введете в это поле какой-либо текст, то вы увидите, что символы получаются синего цвета, т.к. мы указали значение составляющих R, G, B–0, 0 и 100соответственно. В качестве эксперимента,можно изменять значения составляющих–запустив приложение после изменения этих значений,вы увидите, что цвет текста изменяется.Аналогичные опыты можно провести и с цветом фона. Мы задали белый цвет, можно его изменить и перезапустить приложение.

Таким образом, setForeground –это цвет текста, то есть цвет надписи, setBackground–это цвет фона. Оба эти метода требуют указания определенного цвета. Цвет можно указать,выбрав стандартный цвет из перечисленияColor, либо с помощью конструктора new color, указав значение составляющих R, G, B в круглых скобках.

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

Занятие 3. Создание приложения "Калькулятор". Преобразование приложения в апплет

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

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

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

Но вначале немного теории.

Создайте новый проект под названием "lesson15", добавьте к этому проекту класс "prog", нажмите кнопку "Готово"–у вас откроется заготовка программы(комментарии, как обычно, можно удалить).

public class prog {

public static void main(String[] args) {

}

Создайте класс под названием "myClass".Внутри этого класса создайте две переменные. Одна переменная с именем"v1" будет переменной закрытого типа ("private"), а вторая переменная "v2"будет переменной открытого типа("public"):

public class prog {

public static void main(String[] args) {

// Объявление класса

class myClass

{

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

private int v1;

// Переменная класса открытого типа

public int v2;

}

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

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

Мы с вами только что объявили две переменные "v1"и "v2", они будут доступны до первой закрывающей фигурной скобки.

Теперь создадим метод класса под названием "func1()":

// Открытый метод класса

public void func1()

{

}

Напомним, что слово"public"означает"открытый", а "void"–что метод не возвращает никакого значения.

Внутри этого метода объявим еще одну переменную целого типа под названием "v3":

int v3;

Теперь создадим закрытый ("private") метод "func2()"и в нем объявим переменную "v4":

// Закрытый метод класса

private void func2()

{

// Переменная метода

int v4;

}

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

// Объявление класса

class myClass

{

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

private int v1;

// Переменная класса открытого типа

public int v2;

// Открытый метод класса

public void func1()

{

//Переменная метода

int v3;

}

// Закрытый метод класса

private void func2()

{

//Переменная метода

int v4;

}

}

В чем отличие между этими переменными?

Переменная, объявленная внутри метода, называется переменной метода. Переменные "v3"и "v4" –это переменные метода "func1()"и "func2()" соответственно.

Переменная "v3"доступна только в том фрагменте программы, который будет находиться до закрывающей фигурной скобки метода "func1()".Например, внутри метода "func2()"переменная "v3"уже будет недоступной. Попытайтесь присвоить ей какое-то значение внутри метода "func2()". Вы увидите - она подчеркивается красным цветом, что свидетельствует об ошибке.

То же самое можно сказать и о переменной "v4". Ее можно использовать только до закрывающей фигурной скобки метода "func2()".

Переменные класса"v1"и "v2"объявлены выше. Т. е.закрывающая фигурная скобка, которая ограничивает их действие, находится в самом низу класса. Таким образом, внутри метода "func1()"и"func2()"переменные "v1" и"v2"будут доступными. К этим переменным можно обратиться в любой точке класса.

Переменные, которые мы объявляем внутри методов, уничтожаются в оперативной памяти компьютера, когда этот метод заканчивает свою работу. Таким образом, закрывающая фигурная скобка символизирует окончание работы этого метода. В момент вызова метода "func1()"и "func2()"будут созданы переменные "v3" и"v4". По окончании работы этих методов, эти переменные в оперативной памяти компьютера будут уничтожаться, их уже не будет существовать.А переменные "v1"и "v2"будут существовать, и их можно использовать внутри любого метода класса. Все это нужно учитывать при разработке приложений, при использовании той или иной переменной в какой-либо точке программы.

Создадим объект на основании нашего класса "myClass"с помощью переменной под названием "ob".

public class prog {

public static void main(String[] args) {

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

myClass ob = new myClass();

// Вызов метода класса

ob.func1();

// Присваивание значения

// переменной класса

ob.v2 = 400;

}

}

Этот объект мы создали на основании класса, который описан ниже.Теперь попробуйте обратиться к переменной"ob". Когда вы воспользуетесь оператором ".", вы увидите окно подсветки. В появившемся списке будет доступна переменная "v2"и метод "func1()", но переменная "v1"и метод "func2()"являются недоступными, потому что мы их сделали закрытыми", установив модификатор доступа"private". Отсюда следует, что переменные и методы закрытого типа доступны только внутри класса. Так как метод "func1()"является открытым, то он доступен для объекта,созданного на основании этого класса. Этот метод можно вызвать внутри метода "func2()", и это не будет являться ошибкой, т. к. закрытый метод не доступен за пределами класса, но доступен внутри класса.

// Объявление класса

class myClass

{

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

private int v1;

// Переменная класса открытого типа

public int v2;

// Открытый метод класса

public void func1()

{

// Переменная метода

int v3;

v3 = 100;

v1 = 200;

func2();

}

// Закрытый метод класса

private void func2()

{

// Переменная метода

int v4;

v4 = 200;

v2 = 200;

func1();

}

}

Таким образом, внутри метода "func1()"можно вызвать метод "func2()", и внутри метода"func2()"вызвать метод "func1()".Внутри класса эти методы можно вызывать произвольно, вне зависимости от того,являются они открытыми или закрытыми. Но за пределами класса можно обращаться только к открытым методам и переменным класса.

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

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

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

Первая "text"типа "JTextArea" - текстовое поле,в которое у нас выводится результат. Далее переменные "p1" и"p2"типа "double" (это тип, который поддерживает и дробную часть, так как,например, после деления мы с вами можем получить дробное число). Переменные"p1"и "p2"будут хранить те значения, которые мы вводим для выполнения над ними арифметической операции. Т. е.,если пользователь после цифры "1", потом нажмет на кнопку "+", эта цифра будет записана в качестве значения переменной"p1". А когда пользователь введет второе число, оно будет записано в качестве значения переменной "p2".После выполнения арифметической операции мы получим результат, который запишем его в качестве значения переменной "p1". И четвертая переменная "oper"типа "int".

То есть каждый раз, мы будем помещать результат в переменную"p1". Зачем это необходимо? Для того чтобы пользователь мог продолжить выполнение арифметических операций. Например, сначала он выполнил сложение двух чисел, затем захотел выполнить еще одну операцию с полученным результатом. Вот поэтому каждый раз мы будем помещать результат снова в переменную "p1" -она будет содержать результат предыдущего шага вычислений.

Для хранения выбранной пользователем операции будем использовать переменную под названием "oper".Если пользователь, выберет операцию сложение ("+"), то значение переменной будет равно 1. Всего эта переменная может принимать одно из четырех значений: 1, 2, 3, 4. Эти цифры обозначают сложение, вычитание, умножение и деление соответственно.

Вспомним, когда мы создавали кнопки, то к каждой из них мы подключали обработчик событий, и прописывали вызов одного метода под названием "btnClick()". Мы это сделали для того, чтобы не прописывать обработку событий для каждой кнопки, а внутри одного метода обрабатывать нажатие на любую кнопку калькулятора. В метод "btnClick()"мы передаем параметр, поэтому у него в скобках установлен параметр типа "JButton" с названием"btn", то есть мы в этот метод передаем ту кнопку, которую нажал пользователь, а точнее данные об этой кнопке. Таким образом, внутри метода "btnClick()"мы всегда сможем определить, какую именно кнопку нажал пользователь, и в зависимости от этого выполнять те или иные действия.

Метод "actionPerformed()" срабатывает при нажатии на кнопку, и через его аргумент под названием "e"типа "ActionEvent" мы можем определить, какая конкретно кнопка была нажата, поэтому мы передаем параметры"e". Метод "getSource()"позволяет получить нажатую кнопку и передает информацию об этой кнопке методу "btnClick()".

Перейдем к методу"btnClick()". Этот метод как раз и реализует весь основной программный функционал калькулятора.Первое, что мы с вами добавим, мы создадим переменную "str"типа "String"(строкового типа). В эту переменную мы будем возвращать имя кнопки, которую нажал пользователь. Сделать это можно с помощью метода "getText()",обратившись к переменной "btn" ("btn"- это как раз та кнопка,которую нажал пользователь). Таким образом,у нас получится строка программного кода:

// Определяем название нажатой кнопки

String str = btn.getText();

Запустим приложение.Если вы нажмете кнопку "Выход", то метод "getText()"получит значение "Выход"и присвоит его переменной "str". Если вы нажмете кнопку "=", то значением переменной "str" будет символ "=". Метод "getText()" получает тот текст, который указан на кнопке.

Сначала опишем действие для кнопки "Выход", по которой осуществляется выход из программы. Выход из программы можно организовать с помощью команды System.exit(0). Параметр "0"означает, что выход нормальный, не аварийный. Для проверки условия нажатия нaкнопку воспользуемся условным операторомif. Проверять будем значение переменной "str". Мы получим следующую алгоритмическую конструкцию: "Если str=="Выход",тогда нужно выйти из программы, выполнив команду System.exit(0). На языке Java это будет выглядеть так:

// Если нажата кнопка Выход -

// завершаем работу приложения

if (str=="Выход")System.exit(0);

В ветке "Иначе Если" - "else if…"опишем действие для следующей кнопки"С" (Очищение окна результата). Очистить поле можно при помощи метода "setText()". Этот метод позволит вывести любой текст, указанный в круглых скобках в необходимое поле. Нам нужно чтобы в текстовом поле результата было пусто.Пустая строка вводится при помощи двух кавычек - "".Переменным "p1" и"p2"нам нужно присвоить значение "0". На языке программирования Java это будет выглядеть так:

//Если нажата кнопка очистить поле

else if (str=="C")

{

// Очищаем поле -выводом в него

// пустой строки

text.setText("");

// Обнуляем переменные

p1=p2=0;

}

При помощи такой конструкции "if"можно перебирать любое количество условий.

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

Integer.parseInt();

В число мы будем переводить содержимое текстового поля"text", которое позволяет получить метод "getText()":

Integer.parseInt(text.getText());

После преобразования нам нужно узнать, какую операцию выбрал пользователь. Номер выбранной операции хранит переменная "oper". Если она равна "1", нам нужно выполнить сложение. Результат нам нужно вернуть в текстовое поле. Результатом выполнения операции будет число. Значит,нам нужно будет выполнить обратную операцию –преобразовать число в строку. Сделать это можно с помощью неявного преобразования–прибавив к пустой строке число:

""+(p1+p2)

Этот результат нужно записать обратно в текстовое поле. Сделать это можно при помощи метода "setText()":

text.setText(""+(p1+p2))

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

Прежде чем выполнить эту операцию, нужно проверить,действительно ли пользователь выбрал операцию "сложение", значение переменной"oper"равно1:

if (oper==1) text.setText(""+(p1+p2));

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

if (oper==2) text.setText(""+(p1-p2));

if (oper==3) text.setText(""+(p1*p2));

if (oper==4) text.setText(""+(p1/p2));

В целом, программный код для кнопки "=" будет выглядеть следующим образом:

// Если нажата кнопка Равно - вычисляем

else if (str=="=")

{

// Перевод из строкового типа в целое число

p2 = Integer.parseInt(text.getText());

// В зависимости, какая была ранее выбрана

// операция - производим вычисление

if (oper==1) text.setText(""+(p1+p2));

if (oper==2) text.setText(""+(p1-p2));

if (oper==3) text.setText(""+(p1*p2));

if (oper==4) text.setText(""+(p1/p2));

}

Теперь описываем действие кнопки "+" (Сложение). В этом случае нам нужно проверить условие str=="+":

else if (str=="+")

После того как пользователь нажмет на кнопку "+" (условие выполнится), в переменную "oper" нужно вернуть номер операции сложения – "1":

//Устанавливаем значение переменной oper

// - которая отвечает за вид выбранной

//арифметической операции

oper = 1;

В этот же момент в переменную "p1"нужно поместить число, которое ввел пользователь. Но пользователь ввел значение в текстовое поле, следовательно,нам нужно преобразовать текстовое значение в числовое. Как вы помните, в переменную "p1"мы будем помещать результат выполнения операции. Результатом выполнения деления редко когда является целое число. Поэтому тип Integerнам не подойдет. Мы воспользуемся другим типом–Double. Значение в этот тип будем преобразовывать с помощью метода"parseDouble()". Таким образом, значение переменной "p1" будет равным:

// Переводим из строкового типа в числовой

p1 = Double.parseDouble(text.getText());

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

// Очищаем поле

text.setText("");

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

// Если нажата кнопка Минус

else if (str=="-")

{

oper = 2;

p1 = Double.parseDouble(text.getText());

text.setText("");

}

// Если нажата кнопка Умножить

else if (str=="*")

{

oper = 3;

p1 = Double.parseDouble(text.getText());

text.setText("");

}

// Если нажата кнопка Делить

else if (str=="/")

{

oper = 4;

p1 = Double.parseDouble(text.getText());

text.setText("");

}

Нам осталось определить команды, которые должны срабатывать, если пользователь нажал одну из цифр: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9. В этом случае нет необходимости для каждой цифры прописывать отдельную конструкцию "else if"- команды мы запишем в ветке "else".Команды ветки"else" срабатывают в том случае, если не выполнилась ни одна из вышеперечисленных конструкций.

Если пользователь нажал цифру, тогда мы должны отобразить ее в текстовом поле. Причем каждую следующую выбранную цифру нужно отображать в конце.Т. е. каждую новую цифру мы "приклеиваем" к предыдущей справа. Например, нам нужно ввести число 215. Значит, нам нужно сначала нажать цифру 2, затем 1 (получится 21), а затем цифру 5. (получится 215). Вспомним, что название кнопки у нас хранит переменная"str". Как только пользователь нажмет на какую-либо цифру,например, 2, это значение должно быть записано в переменную "str". Т. е., к пустому значению мы прибавляем символ 2. Получить введенный символ нам поможет командаgetText() . Т. е. на этом шаге мы получим, что

""+text.getText()

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

""+text.getText()+str

Для того чтобы программа воспринимала знак "+" как операцию конкатенации - мы должны в качестве первого слагаемого записать обязательно строку. В противном случае она сама может преобразовать значение текстового поля в число (совершить так называемое неявное преобразование). В качестве первого слагаемого мы поставили пустую строку. Число, введенное пользователем нужно вернуть в это же поле.Для этого воспользуемся командой setText().Тогда единственная команда ветви "else…"будет иметь вид:

else

{

// Прибавляем нажатую цифру справа от других цифр<