Для того чтобы начать наше занятие, давайте запустим нашу Среду разработки Eclipse.
Итак, мы создали новый проект. Проект – это своего рода папка, в которой находится программа. Наша программа представляет из себя файл с текстом, созданным в виде набора специальных команд, специальных конструкций,которые используются в программировании.
Если вы откроете предыдущие проекты, то внутри папки нашего проекта увидите ветку src, которая содержит нашу программу. Откройте её и в ней найдете папку (пакет по умолчанию), открыв этот пакет, вы обнаружите вашу программу с расширением .java. (cм. рисунок 31):
Рисунок 31
Все, что мы будем создавать – все программы, весь программный код (наш текст программы) будет находиться в файлах с расширением.java. И хотя имя у каждой программы будет своё: prog1, prog2; сейчас мы уже создали prog3, но расширение всегда остается .java. Если вам нужно посмотреть содержимое любой из наших предыдущих программ - дважды щелкните мышью на наименовании программы и откроется текст самой программы. Сверху появляются новые закладки. Их можно открыть и закрыть в любой момент. Для примера откройте проект lesson2 (для этого следует открыть папку с проектом, зайти в папку src,открыть еще одну вложенную папку - (пакет по умолчанию), щелкнуть двойным щелчком мыши на файл prog2.java). Для сохранения содержимого программы следует выполнить последовательность действий: Файл→Сохранить всё.
При добавлении нового текста в программу, сверху в наименовании появляется звездочка *, указывающая на то, что последние изменения, внесённые в программный файл, еще не сохранены на диске (после сохранения новых данных эта звездочка пропадает). (cм. рисунок 32).
Рисунок 32
Давайте начнем создавать новый проект. Сверху следует добавить однострочный комментарий: Урок №3 и подключить (на следующей строчке)библиотеку для работы с окнами: import javax.swing.*; - у нас получится следующий программный код:
// Урок №3
import javax.swing.*;
public class prog3 {
public static void main(String[] args) {
}
}
Теперь можно приступить к написанию программного кода.
Введем в нашу программу три переменные:
int val = 100;
char ch = 'd';
String str = "Hello!";
Для выведения любой из переменных на печать пишется соответствующая команда с обращением к имени переменной, выводимой на печать,например:
System.out.println(str);
Создадим новое окно, которое нужно вывести на экран:
JFrame nf = new JFrame();
nf.setVisible(true);
Запустим программу на выполнение. Высветилось маленькое окошко, т.к. размеры ему мы ещё не задали.
Зададим их, добавим перед отображением окна еще одну строчку:
nf.setBounds(50, 50, 300, 300);
Обратите внимание: созданное нами имя окна nf также является именем переменной. Мы уже знаем, что переменная может быть целым числом, может быть, например, символом, может быть строкой. Оказывается, бывают переменные и более сложного типа. Например, тип переменной – JFrame – тип окно
JFrame nf = new JFrame();
При написании этого кода в памяти компьютера так же выделяется определенная область, она называется nf. Это и есть имя нашей переменной. Но при создании такой переменной в памяти компьютера выделяется область для характеристик окна (ячейки памяти). Т.е., мы создали переменную с типом окно. И хотя мы пока окно не видим, т.к. ещё не выводили его на экран,но оно уже существует и занимает некоторую память.
Затем мы нашему окошку присвоили некоторые свойства(характеристики: расположение на экране; размеры: ширина, высота), - с помощью команды
nf.setBounds(50, 50, 300, 300);
И, наконец, последняя команда делает окно видимым на экране:
nf.setVisible(true);
Если последнюю команду закомментировать:
// nf.setVisible(true);
и запустить программу на выполнение, мы ничего мы не увидим на экране, хотя в памяти компьютера это окно есть.
Итак, в данном случае, nf – это тоже же имя переменной. Если в случаях
int val = 100;
char ch = 'd';
String str = "Hello!";
вы через имя val обращались к числу, через ch – к символам, через str – к строке, то через наименование переменой nf вы обращаетесь к окну, таким образом, у вас есть более сложная переменная, к которой вы тоже можете обращаться.
Создадим теперь вторую переменную, описывающую окно. Для этого скопируем в программе блок:
JFrame nf = new JFrame();
nf.setBounds(50, 50, 300, 300);
nf.setVisible(true);
Поместите вставляемый блок под первым и переименуйте первую переменную из nf в nf1. Тогда и в обращениях к ней тоже измените имя nf на nf1.
Вторую переменную назовем nf2. После этих действий мы получим следующую программу:
// Урок №3
import javax.swing.*;
public class prog3 {
public static void main(String[] args) {
JFrame nf1 = new JFrame();
nf1.setBounds(50, 50, 300, 300);
nf1.setVisible(true);
JFrame nf2 = new JFrame();
nf2.setBounds(50, 50, 300, 300);
nf2.setVisible(true);
}
}
Задайте новому окну ширину и высоту 100, а расположение,например, по 500 пикселей отступ сверху и слева.
nf2.setBounds(500, 500, 100, 100);
Запустите программу на исполнение. У вас должны появиться на экране два окна с разными параметрами – они разного размера и находятся в разных местах. Второе окошко меньше первого и находится дальше от левого верхнего угла. Можно переключаться между ними. Таким образом, с помощью копирования этих нескольких строчек можно создавать все новые и новые окна.
А как быть, если вам понадобится не 2 или 3, а 100, или,может быть, 1000 окон? Неужели придётся столько же раз копировать, вставлять,да ещё править каждый блок? Оказывается, можно не заниматься этой утомительной работой.
Нам для вывода на экран, например, 10 окон требуется 10 раз выполнить три команды:
§ создать новое окно;
§ задать ему размеры;
§ сделать окно видимым.
Такую последовательность действий (алгоритм), которую необходимо повторять какое-либо количество раз называют в программировании циклом.
В языке Java существует такая конструкция, которая носит название "цикл for". Давайте рассмотрим программный код с ее применением:
// Урок №3
import javax.swing.*;
public class prog3 {
public static void main(String[] args) {
for (int i=1; i<=10; i++)
{
JFrame nf = new JFrame();
nf.setBounds(i*100, i*100, i*100, i*100);
nf.setVisible(true);
}
}
}
Попробуйте набрать программный код и запустить программу.Если программный код написан без ошибок, то на экране появится сразу десять окон. Они создались автоматически, благодаря работе цикла for.
Цикл for всегда начинается со служебного слова for –маленькие английские буквы, и оно выделяется таким же специальным цветом, как и все служебные слова. Дальше в круглых скобках идет настройка цикла. С помощью,так называемого, счётчика цикла i задаётся количество повторений работы цикла. В нашем случае цифра 10 определяет количество окон, созданных в цикле.Изменим 10 на 100, и цикл будет работать, пока не создаст 100 окон. Дальше в фигурных скобках (одна открывающая, вторая закрывающая) расположены строчки программного кода, описывающие действия, которые цикл должен сделать заданное число раз. Эти строки цикл выполняет несколько раз, в нашем случае десять раз:
JFrame nf = new JFrame();
nf.setBounds(i*100, i*100, i*100, i*100);
nf.setVisible(true);
С помощью этих строк сначала создается новое окно, затем устанавливаются его размеры, положение на экране, а третья строка делает окно видимым на экране.
Вернёмся к счётчику цикла. Это переменная целого типа, в данном случае она называется i и ей присваивается начальное значение, равное единице. Т. е., в соответствующей ячейке памяти с именем i помещается значение1. Дальше мы определяем условие, при котором будет работать наш цикл: нам нужно, чтобы на экран было выведено 10 окон, т.е. i будет меньше или равно 10,наш цикл будет работать. Начальное значение i = 1 – будет создано первое окно.Команда i++ прибавляет к значению переменной i единицу, на следующем шаге цикла значение i будет следующее 1+1=2 – и будет создано второе окно. Это действие будет выполняться на каждом шаге цикла, пока следующее значение переменной не достигнет 10. Цикл завершится. Результатом его работы будет наличие 10 вновь созданных окон.
Разберем поэтапно, с самого начала, что будет происходить.Цикл начинает выполняться,
Шаг №1: на этом шаге i=1, условие наше – i<=10выполняется (i действительно меньше 10).
§ Создается новое окно,
§ устанавливается его местоположение, параметры рассчитываются по заданным формулам (i*100, i*100, i*100, i*100), в качестве i подставляется значение переменной, на этом шаге оно равно 1, поэтому создается окно с размерами nf.setBounds(100,100,100,100);
§ окно делается видимым, то есть отображается на экране.
Дальше цикл переходит на свой второй шаг.
Шаг №2:
§ Выполняется команда i++. Соответственно, i=2;
§ Снова создается окно,
§ устанавливается его местоположение, параметры рассчитываются по заданным формулам (i*100, i*100, i*100, i*100), в качестве i подставляется значение переменной, на этом шаге оно равно 2, поэтому создается окно с размерами nf.setBounds(200,200,200,200);
§ окно делается видимым, то есть отображается на экране.
Потом цикл опять идет на свой следующий шаг, к iприбавляется еще одна единичка. На всех шагах цикла i будет принимать значения:1, 2, 3, 4, 5, 6, 7, 8, 9,10 и цикл будет выполняться до тех пор, пока i <= 10. В тот момент, когда i у нас станет =10, цикл выполниться последний раз:
Шаг №10:
§ Выполняется команда i++. Соответственно, i=10;
§ Снова создается окно,
§ устанавливается его местоположение, параметры рассчитываются по заданным формулам (i*100, i*100, i*100, i*100), в качестве i подставляется значение переменной, на этом шаге оно равно 10, поэтому создается окно с размерами nf.setBounds(1000,1000,1000,1000).
После выполнения этого шага программа выйдет из цикла и пойдет дальше.
Итак, настроечная часть цикла устроена следующим образом: в круглых скобках – первая часть устанавливает начальное значение счетчика цикла,вторая часть описывает условие выполнения цикла, третья часть – изменение счетчика в цикле. Обратите внимание, что здесь, в конце этой строки знак точка с запятой ";" не ставится.
Наш цикл выводит 10 окон подряд, и все они имеют разный размер и размещены в разных местах, т.к. i на каждом шаге цикла имеет разное значение. У каждого следующего окна координата левого верхнего угла увеличивается на одинаковую величину по горизонтали и вертикали, поэтому окна размещаются по диагонали. Увеличивается и размер каждого последующего окна.
Давайте теперь сделаем все окна одинакового размера. Для этого зафиксируем ширину и высоту окна, а изменение координаты угла сохраним (cм.рисунок 33).
Рисунок 33
Давайте запустим заново нашу программу и посмотрим, что изменится (все окна должны получиться одинакового размера, и должны быть расположены по диагонали).
Теперь уменьшим количество циклов с 10 до 5, для этого изменим строку с настройкой цикла for:
for (int i=1;i<=5;i++)
Запустим программу - создалось 5 окошек, т. е. в 2 раза меньше.
Попробуем расположить окна не по диагонали, а в один ряд –по горизонтали. Это значит, что одна – вертикальная координата изменяться не будет, и в этом случае строка задания параметров окна будет выглядеть теперь так:
nf.setBounds(i*100, 0, 100, 100);
Заново запустим программу - все окошечки расположились горизонтально в ряд, т.к. второй параметр для всех окон равен 0, т.е. её изменения по вертикальной оси не происходит. Кроме того, 0 – самая верхняя точка экрана, поэтому окошки находятся наверху (cм. рисунок 34).
Рисунок 34
Если взять значение больше 0, горизонтальный ряд окошек опустится ниже. Если присвоить постоянное значение горизонтальной координате, а вертикальной координате – переменное значение, – получим вертикальный ряд окошек, в этом случае строка задания параметров окна будет выглядеть теперь так:
nf.setBounds(0, i*100, 100, 100);
Цикл выполняет то, что идет внутри фигурных скобок после описания цикла. Часть цикла, заключённая в фигурные скобки, называется телом цикла. Тело цикла содержит команды, выполняемые многократно. Когда цикл закончит свою работу, выполнение программы пойдет дальше – она обратится к командам, записанным ниже.
В программировании циклы используются очень часто. Регулярно возникает необходимость многократно выполнять различные действия, которые можно помещать в цикл для их автоматического выполнения.
Рассмотрим еще одну алгоритмическую конструкцию, которая называется "if".
Пусть у нас есть программная задача: Два имени – Петя и Маша. Нужно проанализировать два имени – Петя и Маша, и результат анализа вывести на экран: если записано имя Петя, на экран нужно вывести сообщение "мальчик",если записано имя Маша, соответственно, – "девочка".
Запишем программный код такой задачи, и разберем подробно,как программа выполняется. Для этого создадим переменную типа String – строка,назвав её strp, присвоим ей значение Маша (значение указывается в двойных кавычках), получившаяся строка будет иметь вид:
String strp = "Маша";
Воспользуемся конструкцией if для анализа значения переменной:
if (strp=="Маша")//если значение переменной равно "Маша"
{
System.out.println("Девочка");//Выводим сообщение "Девочка"
}
В данной конструкции, в круглых скобках указываются условия,которые необходимо проанализировать (говоря простым языком: мы как бы задаём вопрос – выполняется это условие или нет?). Мы написали на языке программирования следующую фразу: если strp переменная есть "Маша",тогда выполнить действия, которые находятся в фигурных скобках (одна –открывающая, другая – закрывающая). В данном случае, действие у нас одно, оно означает вывод сообщения на экран.
Попробуем запустить эту программу. У нас появилось сообщение в консольном окне: "Девочка". (т. к. значение строки String strp="Маша", то условие выполнится). Если условие выполняется,происходит выполнение блока команд, помещённых в фигурные скобки { }. Если это условие не выполняется, выполнения блока команд не происходит. В этом легко убедиться: попробуем присвоить строчной переменной strp значение Петя, для этого необходимо внести изменения в строку:
String strp = "Петя";
Попробуем запустить программу на исполнение. Теперь условие не выполняется. Следовательно, команда System.out.println("Девочка");не выполняется – на экран ничего не выводится.
У конструкции if есть и вторая часть. Она называется else.Чтобы понять, как она работает, рассмотрим пример:
String strp = "Петя"; if (strp=="Маша")
{ System.out.println("Девочка");
}
else
{
System.out.println("Мальчик");
}
Пусть теперь значение строчной переменной равно Петя.Конструкция if анализирует условие: если оно равно Маша, то вывести на экран сообщение Девочка. В нашем случае условие не выполняется – значение строчной переменной strp не равно Маша, поэтому сообщение "Девочка" на экран не выводится. Далее программа переходит к конструкции else.
Конструкция else работает, если условие не выполняется.Сработает команда, прописанная в конструкции else, и на экран выведется сообщение "Мальчик". Запустим программу – на экране появилось сообщение "Мальчик".
Конструкция else всегда работает только тогда, когда условиеif не выполняется!
Например, если поменять значение переменной strp="Петя"на "Маша", мы получим код:
String strp = "Маша";
if (strp=="Маша")
{
System.out.println("Девочка");
}
else
{
System.out.println("Мальчик");
}
Перезапустим программу - на экране появляется сообщение "Девочка".Теперь условие if выполнено. Сработала команда, указанная в фигурных скобках конструкции if. Конструкция else в данном случае не была задействована. Блокиifиelseникогда не выполняются одновременно, всегда выполняется только один из них, т.к. условие либо выполняется,либо нет, условие не может быть выполненным и одновременно не выполненным.Возможно, вы уже заметили, что в конце строки
if (strp=="Маша")
знак точка с запятой";"отсутствует.Этот знак не ставятся после таких специальных конструкций, как ifили for.
Необходимо обратить отдельное внимание на то, что в условии сравнения знак равенства ставится дважды(!!!) - ==. Двойной знак равенства ==говорит именно о сравнении!
Конструкция if носит и другое название – условная алгоритмическая конструкция (т.к. мы анализируем условие и, в зависимости от его выполнения, запускаем одну, либо другую последовательность команд).
