Import javax.Swing.*; // Подключение библиотеки для работы с окнами
public class prog4 {
public static void main(String[] args) {
// Создаем объект на основании класса JFrame
JFrame nf = new JFrame();
// Устанавливаем параметры его расположения, ширину,высоту
nf.setBounds(100, 50, 500, 300);
// Показываем окно на экране
nf.setVisible(true);
}
}
Строка importjavax.swing.* подключает к нашей программе библиотеку для работы с окнами.
Строка JFramenf = new JFrame()создает объект типа JFrame – это класс окон, класс, который уже создан для нас с вами, чтобы на основании этого класса могли создавать конкретные объекты - окна. Т.к. сейчас мы пользуемся готовым классом, то внизу программы мы не создаем новый класс. Другими словами мы можем создавать свои классы, а можем использовать уже существующие.
Итак, мы воспользовались классом JFrame,объявили переменную nf типаJFrame, и создали новый объект. Запись new JFrame()- это создание нового объекта. Имя переменной может быть любым в соответствии с правилами объявления переменных.
В строке кода
nf.setVisible(true);
используется тип – boolean.В данном случае указано одно из двух его значений, которое означает истина– true: ("Показать окно?", "Да,показать"). Если сейчас запустить программу, мы увидим реальное окно –объект, созданный нами на основании класса окон. Этот класс изначально предоставляется средой разработки Java, т.е.он уже создан для пользователей, чтобы на его сновании можно было создавать свои окна. Класс у нас один – JFrame, но на его сновании можно создать сколько угодно объектов, т.е. окон.
Рассмотрим еще одну очень важную тему – понятие наследования.Это понятие очень тесно связанно с объектно-ориентированным программированием.Понятие наследования нам понадобится для создания программ с элементами компьютерной графики. Вспомните – мы создавали класс под названием животные– givotn с несколькими характеристиками.Предположим, теперь нам нужно создать класс слонов – slon. Мы создадим этот класс слонов при помощи наследования - наследования от класса животных. Слон – разновидность животного.Все характеристики, которыми обладают животные, присущи и слону.У слона тоже есть масса, есть признаки – является ли он подводным,летающим или сухопутным. Следовательно, класс слон можно создать на основании другого класса – животные. Все свойства класса животные при этом автоматически перетекают в класс слон. Это и есть принцип наследования: слон сразу же,автоматически получил свойства животных, т.е., массу и 3 признака, т.е.,в данном случае, класс слон является потомком класса животные. (cм. рисунок 37).
Рисунок 37
Класс животные является родительским классом класса слон.Класс слон произошел от класса животные. Предположим, нам важно знать скорость передвижения слонов. Значит, в класс слон нужно добавить ещё одну дополнительную, пятую, характеристику – скорость передвижения.Остальные признаки, характеризующие всех животных, в классе слонуже есть. Это удобно, т. к. при создании нового класса не приходится заново прописывать уже обозначенные в существующем классе свойства. Кроме того,программный код получается менее громоздким. При помощи принципа наследования мы освобождаем себя от рутинной работы: прописав сначала свойства, присущие всем животным, - мы эту работу выполнили раз и навсегда. Классу слон мы только добавляем свойства, характеризующие конкретно слонов, т.е. дополняем признаки, присущие слонам и необходимые в нашей задаче.
Добавим новый класс под названием орёл. Этот класс тоже наследуется от класса животные и является его дочерним классом.Класс животные – родительский класс. Класс орёл тоже приобрел свойства класса животные: масса и 3 характеристики, прописанные в программном коде. В случае орла, нам интересно знать высоту его полёта.Значит, к свойствам, присущим всем животным, в класс орлов нужно добавить новую характеристику (cм. рис 37).Программный код будет в этом случае выглядеть так:
// Урок №4
public class prog4 {
public static void main(String[] args) {
}
}
// Класс животных
class givotn
{
int mas;
boolean podvod;
boolean suhoput;
boolean let;
}
//Класс слонов, наследуется от класса животных
class slon extends givotn
{
int skorost; // Скорость передвижения
}
//Класс орлов, наследуется от класса животных
class orel extends givotn
{
int visota; // Высота полета
}
Класс givotn мы уже создавали ранее. Теперь у этого класса у нас добавились еще два подкласса. Первый класс под названием slon.Слово extends означает: класс slon наследуется от класса givotn, т.е. наследует, копирует все характеристики этого класса. Это действие и прописано в строке:
class slon extends givotn
После объявления этого класса внутри фигурных скобок указали одну характеристику, которая присуща только классу слонов:
{
int skorost; // Скорость передвижения
}
Остальные четыре поля в классе slon уже существуют, они прописаны в классе givotn. Как только была создана строка
class slon extends givotn
эти четыре поля автоматически появились в классе slon – наследовались.
Теперь рассмотрим другой класс под названием orel. Он также наследуется от класса givotn.И мы также указываем только одну характеристику, присущую только этому классу,а остальные прописаны в классе givotn:
{
int visota; // Высота полета
}
Таким образом, был создан базовый класс – основной (родительский)класс под названием givotn, имеющий 4 поля – 4признака, характеристики. А потом путём наследования от класса givotn был создан класс slon, затем класс orel. В каждый их этих классов было добавлено по одному новому полю – их индивидуальные характеристики: для класса slon - скорость передвижения, для класса orel – высота полёта. Таким образом, была создана структура, иерархия классов. Попробуем создать два объекта – слона и орла:
// Урок №4
public class prog4 {
public static void main(String[] args) {
slon mySlon = new slon(); // Создан объект слон
mySlon.mas = 5000;
mySlon.let = false;
mySlon.podvod = false;
mySlon.suhoput = true;
mySlon.skorost = 15; // Задана скорость передвижения слона
orel myOrel = new orel(); // Создан объект орел
myOrel.mas = 5;
myOrel.let = true;
myOrel.podvod = false;
myOrel.suhoput = true;
myOrel.visota = 1000; // Задана высота полета орла
}
}
// Класс животных
class givotn
{
int mas;
boolean podvod;
boolean suhoput;
boolean let;
}
//Класс слонов, наследуется от класса животных
class slon extends givotn
{
int skorost; // Скорость передвижения
}
//Класс орлов, наследуется от класса животных
class orel extends givotn
{
int visota; // Высота полета
}
Таким образом, мы создали два объекта: первый на основании класса slon, а второй на основании класса orel. Объекты созданы по все по той же схеме: первоначально объявляется переменная с типом нужного класса - создается объект. Далее, вводим имя объекта, в данном случае mySlon и myOrel в самом конце ставим оператор точка . и выбираем из списка нужную характеристику объекта. Главное, на что стоит обратить внимание – это то, что у объектов mySlonи myOrel четыре характеристики совпадают, потому что они унаследованы от класса givotn.
А одна характеристика у каждого объекта своя, у mySlon – это skorost, а у myOrel – это visota (cм. рисунок 38).
Рисунок38
Если посмотреть на описание наших трех классов, то вы увидите, что в классах slon иorel определено всего по одному полю, но при задании характеристик объектам используются и четыре поля из класса givotn. Это происходит благодаря наследованию!
// Класс животных
class givotn
{
int mas;
boolean podvod;
boolean suhoput;
boolean let;
}
//Класс слонов,наследуется от класса животных
class slon extends givotn
{
int skorost; // Скорость передвижения
}
//Класс орлов,наследуется от класса животных
class orel extends givotn
{
int visota; // Высота полета
}
Слово extends при описании класса – это и есть признак наследования от другого класса, в данном случае от класса givotn.Как только вы указали наследование – вы можете считать, что скопировали в этот класс все, что было в классе, от которого вы наследуете свой новый класс. Так работает принцип наследования в объектно-проектированном программировании.
Без создания классов, объектов невозможно написать полноценное компьютерное приложение.
В качестве примера давайте создадим программу, которая выведет окно на экран, внутри которого нарисован зеленый прямоугольник (cм. рисунок 40).
Рисунок 40
При написании этой программы, нам придется создавать классы,объекты и использовать наследование.
Эта программа будет несколько сложнее тех, которые были созданы нами ранее, и некоторые вещи вам изначально будут не совсем понятны, но позднее вы осознаете ее полностью. Эта программа будет вашей первой программой с использованием компьютерной графики.
Перед началом работы следует удалить из программы код, описывающий классы и объекты, оставив только начальную заготовку программы:
// Урок №4
public class prog4 {
public static void main(String[] args) {
}
}
Ниже текст самой программы, Попробуйте ввести этот код в ваш проект, стараясь не допускать синтаксических ошибок (комментарии вводить необязательно).
// Урок №4
// В этих двух строках подключаются библиотеки для работы с окнами и графикой
import java.awt.*;
import javax.swing.*;
public class prog4 {
public static void main(String[] args) {
// Создание объекта на основании класса myFrame
myFrame okno = new myFrame();
}
}
// Создается новый класс, который наследуется от класса JFrame -класса окон
class myFrame extends JFrame
{
// Метод, который производит начальную настройку окна
public myFrame()
{
// Создаем объект на основании класса myPanel
myPanel panel = new myPanel();
Container cont = getContentPane(); // Обращаемся к содержимому окна
cont.add(panel); // Подключаем (вкладываем) созданную панель в окно
setBounds(10, 10, 300, 400); // Устанавливаем положение и размеры окна
setVisible(true); // Делаем окно видимым
}
}
//Создается новый класс, который наследуется от класса JPanel -класса панелей
// окна
class myPanel extends JPanel
{
// Метод, который рисует содержимое панели окна
public void paintComponent(Graphics gr)
{
super.paintComponent(gr); // Выполняем перерисовку самой панели окна
gr.setColor(Color.GREEN); // Устанавливаем ЗЕЛЕНЫЙ ЦВЕТ
gr.fillRect(10, 10, 200, 300); // Рисуем закрашенный прямоугольник
}
}
Если вы ввели программный код без ошибок, то у вас должен получиться такой же прямоугольник зеленого цвета как на рис 40. Если где-то допущены ошибки, то их придется устранить (где-то, возможно, не стоит точка с запятой,где-то есть ошибка при написании слова, где-то вместо маленькой буквы стоит заглавная или наоборот, а где-то возможно неправильно расставлены фигурные скобки и т.д., подобные ошибки часто появляются на начальном этапе изучения программирования).
Проанализируем программный код.В самом верху этой программы есть главный класс, который был у нас с самого начала, а ниже созданы два новых класса: первый из них – это класс окна,который наследуется от класса всех окон, второй из них – это класс панели,который наследуется от класса всех панелей (cм.рисунок 41).
Рисунок 41
После наследования эти классы сразу же получают все свойства классов, от которых происходит наследование.Отдельно стоит обратить внимание на панель окна, которую мы создали впервые. Панель– это такая прямоугольная область, которую вы как бы вкладываете в окно.Рисование прямоугольника происходит именно на панели, которая потом прикрепляется к нему. За создание панели и прикрепления ее к окну отвечают эти строчки:
myPanel panel = new myPanel(); // Создаем объект на основании класса myPanel
Container cont = getContentPane(); // Обращаемся к содержимому окна
cont.add(panel); // Подключаем (вкладываем) созданную панель в окно
В первой строчке создается объект – панель, во второй строке используется переменная cont,она отвечает за содержимое окна. В третьей строке панель прикрепляется к окну.
Общая структура программы получилась такой: в самом нижнем классе описана панель, внутри этого класса происходит рисование на этой панели. Во втором сверху классе описано окно,внутри этого класса создается объект панели, которая прикрепляется к окну. И в самом верхнем классе создается объект окна, которое мы видим на экране.
Рисование прямоугольника происходит в этой части кода:
// Метод,который рисует содержимое панели окна
public void paintComponent(Graphics gr)
{
super.paintComponent(gr); // Выполняем перерисовкусамой панели окна
gr.setColor(Color.GREEN); // УстанавливаемЗЕЛЕНЫЙ ЦВЕТ
gr.fillRect(10, 10, 200, 300); // Рисуем закрашенный прямоугольник
}
Методpublic void paintComponent(Graphics gr) отвечает за рисование содержимого панели, которая вложена в окно.
Строка:
super.paintComponent(gr);
выполняет рисование самой панели. Следующая строка устанавливает цвет, которым будет происходить рисование:
gr.setColor(Color.GREEN);
а следующая за ней строка выводит на панель закрашенный указанным цветом прямоугольник:
gr.fillRect(10, 10, 200, 300);
В круглых скобках указаны четыре параметра, первый – это отступ в пикселях от левой стороны окна до верхнего левого угла прямоугольника; второй – это отступ в пикселях от верхней стороны окна до верхнего левого угла прямоугольника; третий – ширина прямоугольника;четвертый – высота прямоугольника. Попробуйте по очереди изменять значения этих параметров, запуская программу на выполнение после изменения значения и проанализировать результат наших изменений.