История и развитие методологии объектно-ориентированного программирования. Сферы применения (Теоретические основы объектно-ориентированного программирования)

Содержание:

ВВЕДЕНИЕ

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

Объектно-ориентированное программирование как самостоятельное направление на текущем этапе развития информационных технологий занимает существенную долю всех доступных средств разработки, анализа, проектирования и моделирования.

Особая роль объектно-ориентированных технологий приводит к необходимости детального изучения принципов построения программных компонент информационных систем на базе объектных технологий. При этом объектно-ориентированное программирование (далее – ОП) – это только одно из нескольких самостоятельных направлений изучения и использования теории, в основе которой лежат термины «объект» и «класс». При употреблении термина «объектно-ориентированное программирование» подразумевается вся совокупность всех языков программирования, которые по совокупным признакам можно отнести к данной группе. Такие языки относят к объектно-ориентированным языкам программирования (ООЯП). При этом ОП включает также различные технологии программирования, которые используются на практике при разработке приложений на ООЯП.

Современные технологии объектно-ориентированного программирования интенсивно развиваются – на данный момент программисту недостаточно понимать простейшие принципы ОП (инкапсуляция, полиморфизм, наследование). ОП, как технология, должна реагировать на появление новых требований современного высокотехнологичного мира: параллельный характер процессов в информационных системах; распределенный характер информационных систем; повышение требований к защищенности программного обеспечения: слияние различных технологий разработки приложений и востребованность унифицированного подхода к проектированию и разработке веб-приложений, сервисов, интерфейсов.

Цель курсовой работы узнать больше информации об объектно-ориентированном программировании.

Задачи:

1. Раскрыть теоретические основы объектно-ориентированного программирования

2. Охарактеризовать объектно-ориентированные языки программирования

3. Построить графический интерфейс средствами Java

Объект исследования – объектно-ориентированные языки программирования.

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

Высококвалифицированный программист должен понимать основные ошибки, которые приводят к созданию неэффективных приложений. Программирование приложений должно быть критическим: необходимо использовать различные системы принципов (например, S.O.L.I.D.) и активно применять проверенные паттерны проектирования.

1. Теоретические основы объектно-ориентированного программирования

1.1. История объектно-ориентированного программирования

В отличие от других методологий разработки программного обеспечения объектно-ориентированное программирование (ООП) не ограничивается одним языком программирования, не имеет четкой привязки к конкретному языку программирования. По мнению Вульфа, язык программирования выступает, с одной стороны, как инструмент проектирования, и, с другой стороны, как средство человеческого восприятия, так и как средство управления компьютером [9, c. 478].

В настоящее время насчитывается более двух тысяч языков программирования высокого уровня. Большинство этих языков возникло исходя из конкретных требований некоторой предметной области. Каждый, вновь созданный язык позволяет решать более сложный класс задач на основе применения новых методологий программирования, вводя и обрабатывая новые понятия, взаимоотношения между объектами [4, c. 335].

На развитие языков программирования значительное влияние оказали в то время достижения в теории вычисления, которые привели к формальному пониманию семантики операторов, модулей, абстрактных типов данных и процедур. На рис. 1 представлена генеалогия развития языков программирования, начиная с 1960 г [9, c. 569].

Рис. 1. Генеалогия объектных и объектно-ориентированных языков

Представленные языки программирования сгруппированы в четыре поколения по признаку поддерживаемых ими абстракций: математические, алгоритмические, ориентированные на данные, объектно-ориентированные. Самые последние достижения в области их развития связаны с объектной моделью. Вообще, объектными принято называть языки, которые поддерживают абстракции данных и классы, а объектно-ориентированными являются те объектные языки, которые поддерживают наследование и полиморфизм [16, c. 358].

Язык Simula, созданный в 1960 году Далем, Мюрхогом и Ныгардом, является общим предком объектных и объектно-ориентированных языков. Этот язык основывался на идеях ALGOL, дополнен механизмом наследования и инкапсуляции и предназначался для описания систем и моделирования.

Отметим, что к объектно-ориентированным языкам программирования относятся следующие: Smalltalk, Object Pascal, C++, CLOS и Ada. Шмукер (Schmucker) утверждал, что «Object Pascal – это «скелет» объектно-ориентированного языка. В нем нет методов класса, переменных класса, множественного наследования и метаклассов. Эти механизмы исключены специально, чтобы сделать язык простым для изучения начинающими «объектными» программистами» [18, c. 144].

Рассмотрим наиболее известные технологии, применяемые в программировании и дадим им краткие характеристики [18, c. 41]:

• метод «северо-западного» угла. Пусть имеется лист бумаги или экран дисплея. Программа на этом листе будет писаться сразу от начала до конца, без использования каких-либо общих принципов;
• технология структурного программирования, сочетающая в себе принципы модульности, нисходящего и пошагового проектирования программ, одновременного проектирования программ и структур данных;
• технология объектного программирования. Такая технология связана с использованием понятий объектов и их классов при проектировании программы.

В течение всех лет эволюции развития программирования от программистов требовалось совершенствование технологических приемов и создания на их основе таких средств программирования, которые упростили бы процесс разработки программ, позволяя создавать все более сложные программные системы [17, c. 123].

Известно, что первые программы создавались посредством переключателей на панели компьютера. Очевидно, что такой способ подходил только для небольших программ. Затем программы создавались на машинном языке. Сложность программы ограничивалась способностью программиста одновременно отслеживать последовательность выполняемых операций и местонахождение большого количества данных.

Увеличение сложности программы в дальнейшем было связано с появлением сначала ассемблеров, а затем и языков высокого уровня. Это позволило сделать программу более обозримой за счет снижения уровня детализации [32, c. 35].

Именно подпрограммы позволили существенно снизить трудоемкость разработки программ. Подпрограммы можно было сохранять и использовать в других программах. В результате были накоплены огромные библиотеки расчетных и служебных подпрограмм, которые по мере надобности вызывались из разрабатываемой программы [31, c. 202]. Типичная программа того времени состояла из основной программы, области глобальных данных и набора подпрограмм (в основном библиотечных), выполняющих обработку всех данных или их части (рис. 2).

Рис. 2. Архитектура программы, использующей глобальную область данных

В этой архитектуре слабым местом было то, что при увеличении количества подпрограмм возрастала вероятность искажения части глобальных данных какой-либо подпрограммой. Например, обычно подпрограмма поиска корней уравнения на заданном интервале по методу деления отрезка пополам меняет величину интервала [31, c. 234]. Если при выходе из подпрограммы не предусмотреть восстановления первоначального интервала, то в глобальной области окажется неверное значение интервала, полученное при последнем делении отрезка в ходе работы подпрограммы.

Необходимость исключения таких ошибок привела к идее использования в подпрограммах локальных данных (рис. 3).

Рис. 3. Архитектура программы, использующей подпрограммы с локальными данными

И вновь сложность разрабатываемого программного обеспечения стала ограничиваться возможностью программиста отслеживать процессы обработки данных уже на новом уровне [27, c. 159]. К этому добавились проблемы согласования интерфейса при ведении разработки несколькими программистами. В результате встал вопрос создания технологии разработки сложных программных продуктов, снижающих вероятность появления ошибок.

Усилиями многих авторов такая технология была создана и получила название «структурное программирование».

Структурное программирование нашло свое применение в конце 60-х – начале 70-х годов прошлого столетия в работах Э. Брукса, Н. Вирта, Э. Дейкстры, А.П. Ершова, Э. Йордана, П. Парнаса и др. [27, c. 167]. Основной идеей в данном подходе явилось упорядочение структуры программы путем использования небольшого количества структур управления с ограниченным использованием (или даже вообще без использования) оператора безусловного перехода (goto).

Свойствами структурного подхода являются [19, c. 21]:

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

Были сформулированы основные принципы выполнения разработки программного обеспечения при структурном программировании [19, c. 36]:

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

2) собственно структурное программирование, включающее структуры алгоритмов и стиль программирования;

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

В основе структурного программирования лежит декомпозиция (разбиение на части) сложных систем с целью последующей реализации в виде отдельных небольших (до 40-50 операторов) подпрограмм [18, c. 72]. В отличие от используемого ранее интуитивного подхода к декомпозиции, структурный подход требовал представления задачи в виде иерархии подзадач простейшей структуры, для получения которой рекомендовалось применять метод пошаговой детализации. С появлением других принципов декомпозиции (объектного, логического и т.д.) данный способ получил название процедурной декомпозиции.

Метод пошаговой детализации заключается в следующем [16, c. 245]:

1) определяется общая структура программы в виде одного из трех вариантов: последовательности подзадач (например, ввод, преобразование и вывод данных), альтернативы подзадач (например, добавление записей к файлу или их поиск), повторения подзадачи (например, циклически повторяемая обработка данных);

2) каждая подзадача, в свою очередь, разбивается на подзадачи с использованием тех же структур;

3) процесс продолжается, пока на очередном уровне не получается простейшая подзадача, которая достаточно просто реализуется средствами используемого языка (1-2 управляющих оператора языка).

Дальнейший рост сложности и размеров разрабатываемого программного обеспечения потребовал развития структурирования данных и, соответственно, в языках появляется возможность определения пользовательских типов данных [15, c. 66]. Одновременно усиливается стремление разграничить доступ к глобальным данным программы для уменьшения количества ошибок. Результатом было появление и развитие технологии модульного программирования (70-е годы прошлого века) [15, c.158].

В модульном программировании программа организуется в виде совокупности модулей (функций) (рис. 4).

Рис. 4. Архитектура программы, состоящей из модулей

Разделение на модули должно носить не механический характер, а исходить из логики программы [16, c. 367]:

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

Принцип модульности распространяется не только на программы, но и на данные: любой набор параметров, характеризующих логический или физический объект, должен быть представлен в программе в виде единой структуры данных (структурированной переменной) [16, c. 399].

Благодаря существованию модульного программирования стало возможным расширение библиотеки стандартных функций, которые обеспечивали полный набор параметризованных действий. Данные и процедуры (функции) объединялись в модули в соответствии с логикой проектировщиков программной системы [32, c. 200]. Определяющими факторами являлись свойства предметной области: данные и процедуры их обработки, соответствующие определенному классу сущностей предметной области, объединялись в модуль. Например, модуль обработки строк содержал процедуры и функции, выполняющие основные операции над строками: конкатенация, сравнение, копирование, нахождение подстроки, вычисление длины и т.п.

Кроме того, использование модульного программирования существенно упрощало ведение разработки программного обеспечения несколькими программистами. Каждый из программистов мог разработать свой отдельный модуль. При этом внутренняя организация модулей является скрытой от остальных и, поэтому может изменяться независимо [32, 215]. Разработанные таким образом модули в дальнейшем могли использоваться в других разработках, что увеличивало производительность труда программистов.

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

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

Как отмечалось ранее, основные принципы ООП были сформулированы в середине 60-х гг. XX века при разработке языка Simula [6, c. 414], дальнейшее их развитие пришлось на 70-е годы, когда был создан язык Smalltalk. В середине 80-х годов интерес к этим технологиям повысился, и особую популярность завоевали такие языки, как C++ и Eiffel. Язык программирования С++ был разработан Бьерном Страуструпом, сотрудником компании AT&T. В августе 1998 г. был принят международный стандарт языка С++. ООП продолжало развиваться и в 90-е г. В это время появился язык Java. В 2002 году с выпуском версии Visual Studio.NET компания Microsoft представила на рынке компьютерных технологий новый язык ООП – С# – и модифицированную версию объектно-ориентированного языка программирования Visual Basic [6, c. 417].

Одновременно с развитием объектно-ориентированного программирования стали развиваться и объектно-ориентированные методы разработки программного обеспечения, охватывающие стадии анализа и проектирования. Среди общепризнанных объектно-ориентированных подходов к анализу и проектированию следует выделить методы Г. Буча, Д. Рамбо, А. Джекобсона, Шлеера-Меллора и Коуда-Йордона. В результате объединения усилий первых трех авторов появился на свет унифицированный язык моделирования UML, который в 1997 г. был принят в качестве стандарта консорциумом Object Management Group и получил широкое распространение в сфере производства программного обеспечения [16, c. 374].

Основные идеи объектно-ориентированного подхода опираются на следующие положения [17, c. 416]:

• программа представляет собой модель некоторого реального процесса, части реального мира; модель содержит не все признаки и свойства представляемой ею части реального мира, а только те, которые существенны для разрабатываемой программной системы;
• модель реального мира или его части может быть описана как совокупность взаимодействующих между собой объектов;
• объект описывается набором атрибутов (свойств), значения которых определяют состояние объекта, и набором операций (действий), которые может выполнять объект;
• взаимодействие между объектами осуществляется посылкой специальных сообщений от одного объекта к другому;
• сообщение, полученное объектом, может потребовать выполнения определенных действий, например, изменения состояния объекта;
• объекты, описанные одним и тем же набором атрибутов и способные выполнять один и тот же набор операций, представляют собой класс однотипных объектов.

С точки зрения языка программирования класс объектов рассматривается как тип данных, а отдельные объекты – как данные этого типа [23, c. 101]. Определение программистом собственных классов объектов должно позволить описывать конкретную задачу в терминах ее предметной области (при соответствующем выборе имен типов и имен объектов, их атрибутов и выполняемых действий).

Среди важных преимуществ объектно-ориентированных систем являются [24, c. 315]:

1) концептуальная ясность в разработке системы;

2) надежность системы, вытекающая из простоты работы с ней;

3) повторное использование исходных текстов программ;

4) гибкость при модификации и расширении системы.

Систематическое применение объектно-ориентированного подхода позволяет разрабатывать хорошо структурированные, надежные в эксплуатации, достаточно просто модифицируемые программные системы, которые более адекватно описывают используемые объекты в терминах реального мира [25, c. 117]. Этим объясняется интерес программистов к объектно-ориентированному подходу и объектно-ориентированным языкам программирования по сравнению с другими технологиями программирования.

1.2. Характеристики объектно-ориентированных языков программирования

В теории программирования принято различать объектно-ориентированные и объектные языки программирования. Объектные языки отличаются от объектно-ориентированных языков программирования тем, что не поддерживают наследования свойств в иерархии абстракций. Так, например, Ада – объектный язык, а С++ и объектные версии Pascal являются объектно-ориентированными языками программирования [9, c. 56].

К объектно-ориентированным языкам программирования относятся также и Simula 67, Smalltalk, Eiffel, Java, C#, Visual Basic и др., об эволюции развития которых говорилось ранее.

Объектная модель, использованная при разработке Borland Pascal 7.0, была специально создана для облегчения перехода программистов на использование технологии ООП [11, c. 349]. Эта модель не поддерживает абстракции метаклассов, почти не содержит специальных средств сокрытия реализации объектов. Однако все перечисленные недостатки не влияют на создание более сложных систем.

Особое место занимают объектные модели Delphi и С++ Builder, которые обобщают опыт ООП для MS DOS и включают некоторые новые средства, обеспечивающие эффективное создание более сложных систем. Именно на базе этих моделей созданы визуальные среды для разработки приложений Windows [20, c. 554].

2. Объектно-ориентированное моделирование

Развитие информационных технологий привело к созданию методов объектно-ориентированного анализа, проектирования и программирования, позволяющих создавать крупномасштабное программное обеспечение. Существует несколько парадигм программирования: процедурно-ориентированная, объектно-ориентированная, логико-ориентированная, ориентированная на правила и ориентированная на ограничения. Абстракция выделяет существенные характеристики объекта, отличающие его от всех других видов объектов и, таким образом, проводит четкие концептуальные границы объекта с точки зрения наблюдателя.

Инкапсуляция – это процесс выделения элементов абстракции, образующих ее структуру и поведение; инкапсуляция позволяет отделить контрактный интерфейс абстракции от ее реализации.

Модульность – это свойство системы, разложенной на целостные и слабо связанные между собой модули.

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

Параллелизм – это свойство, отличающее активные объекты от пассивных.

Персистентность – это способность объекта преодолевать временные или пространственные пределы.

2.1. Объектная модель проектирования

Объектно-ориентированная технология основана на строгой теоретической базе. Элементы теории объектно-ориентированной технологии образуют объектную модель проектирования (object model of development) или объектную модель. Основные принципы объектной модели:

– иерархия;

– контроль типов;

– инкапсуляция;

– параллелизм;

– абстракция;

– модульность;

– персистентность.

Данные принципы существуют независимо от объектной модели и не являются ее внутренними свойствами. В рамках объектно-ориентированного подхода указанные принципы образуют синергетическое единство: они дополняют друг друга.

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

Методы структурного проектирования разрабатывались для оптимизации процессов разработки сложных систем на основе алгоритмов. Аналогично, методы объектно-ориентированного проектирования создавались для оптимизации на основе внедрения выразительных средств языков объектного и объектно-ориентированного программирования. В ОП основными компонентами программ являются классы и объекты.

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

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

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

2.2. Объектно-ориентированное программирование

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

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

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

Данное определение показывает важные аспекты:

1) в структурном программировании основными элементами выступают алгоритмы; в объектно-ориентированном программировании основным элементом структурирования программ является объект;

2) объект представляет собой конкретное воплощение определенного класса – его экземпляр (instance of class);

3) классы не существуют в программе обособленно – они объединены в иерархические структуры.

Выполнение этих трех требований позволяет идентифицировать язык как объектно-ориентированный. Существуют языки, в которых может не соблюдаться одно из требований. Например, если в языке не реализовано наследование, то программирование называется не объектно-ориентированным, а программированием с помощью абстрактных типов данных (programming with abstract data types). К таким языкам относится объектно-осведомленный язык Visual Basic 6.0 (VB6).

Принципы, которым удовлетворяет объектно-ориентированный язык:

1) использует объекты, которые являются представлением абстракций предметной области; объекты реализуют различные операции, совокупность которых образует интерфейс объекта; закрытые переменные образуют состояние объекта;

2) каждому объекту поставлен в соответствие класс; существует множество объектов одного класса;

3) классы могут реализовывать механизмы наследования: наследование реализации и наследование интерфейсов.

К объектно-ориентированным языкам относят: Java, C++, C#, Ruby, Smalltalk.

2.3. Проектирование и анализ в рамках объектно-ориентированной модели

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

Основные аспекты, вытекающие из данного определения:

1) ОП основано на представлении системы в виде совокупности объектов – объектная декомпозиция;

2) использует разные системы обозначений для представления логических (объекты и классы) и физических (модули и процессы) моделей системы, а также ее статические и динамические аспекты.

Объектно-ориентированная декомпозиция – основное отличие объектного подхода от структурного. В ОП для выражения логической структуры системы используются классы и объекты, а в случае структурного подхода – алгоритмы и алгоритмические абстракции. Под объектно-ориентированным проектированием иногда понимают различные методы в результате которых получается представление системы в виде объектов.

Методы структурного анализа основаны на исследовании потоков данных внутри программных систем. Существует также объектно-ориентированный анализ (object-oriented analysis). Объектно-ориентированный анализ (ООА) позволяет создавать модели действительности с применением объектно-ориентированного подхода.

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

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

3. Практические приемы разработки приложения

Разработка приложений с графическим интерфейсом, как одно из направлений программирования, отражает практически все достижения и наработки современной объектно-ориентированной технологии.

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

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

В библиотеке Swing, представленной в технологии Java, унификация технологий настольных и сетевых приложений явно не прослеживается. Но следует понимать, что Java как технология изначально ориентирована на использование в сетевой среде: технология Swing применяется как для создания приложений по принципу «толстый клиент», так и для разработки веб-интерфейсов на базе сервлетов (использование Servlet, Java Server Pages, Java Server Faces).

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

3.1. Построение графического интерфейса средствами Java

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

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

В большинстве высокоуровневых языков разработки приложений с ГИП реализованы библиотеки для построения интерфейса пользователя. В языке C# используются технологии Windows Forms и Windows Presentation Foundation. В Java существуют библиотеки AWT и Swing.

Стандартная поставка Java SE включает в себя библиотеку классов, обеспечивающих создание графического интерфейса пользователя (ГИП) (Graphical User Interface, GUI). Эта графическая библиотека получила название JFC (Java Foundation Classes). В библиотеке JFC можно выделить шесть основных частей:

1) AWT (Abstract Window Toolkit) – базовая библиотека классов с несколько устарелым набором «тяжелых» (heavyweight) графических компонентов, расположенная в пакете java.awt и его подпакетах.

2) Swing – библиотека «легких» (lightweight) графических компонентов, дополняющая и во многом заменяющая библиотеку AWT. Занимает почти двадцать пакетов с префиксом javax.swing;

3) Java 2D – часть библиотеки AWT, обеспечивающая рисование графики, выбор цвета, вывод изображений и фигурного текста, а также преобразование их перед выводом.

4) DnD (Drag and Drop) – библиотека классов, позволяющих перемещать объекты из одного компонента в другой с помощью буфера обмена (clipboard). Классы этой библиотеки помещены в пакеты java.awt.datatransfer и java.awt.dnd;

5) Input Method Framework – классы для создания новых методов ввода/вывода. Они занимают пакеты java.awt.im и java.awt.im.spi;

6) Accessibility – библиотека классов для взаимодействия с нестандартными устройствами ввода/вывода: клавиатурой Брайля, световым пером и др. Она расположена в пакете javax.accessibility.

Интерфейс программирования графики (Java Graphics API) представлен двумя технологиями в Java: AWT и Swing.

Возможности технологии AWT разнообразны – AWT состоит из 12 пакетов. В большинстве приложений используются пакеты java.awt и java.awt.event. Это наиболее часто используемые пакеты.

Пакета java.awt содержит:

1) классы, представляющие компоненты ГИП (GUI Component Classes). Эти классы представляют такие элементы как кнопки (Button), текстовые поля (TextField), надписи (Label) и пр.;

2) классы, представляющие контейнеры ГИП (GUI Container Classes). Представляют такие элементы как панель (Panel), фрейм (Frame), диалог (Dialog) и пр.;

3) менеджеры расположения элементов (Layout managers). Это элементы FlowLayout, BorderLayout и GridLayout;

4) вспомогательные классы и графические классы общего назначения (Custom graphics classes). Например, классы для представления цвета (Color), шрифтов (Font).

Пакет java.awt.event, как видно из названия, содержит классы для работы с системой событий и содержит:

1) классы событий (Event classes): ActionEvent, MouseEvent, KeyEvent и WindowEvent;

2) интерфейсы слушателей событий (Event Listener Interfaces): ActionListener, MouseListener, KeyListener и WindowListener;

3) классы адаптеров слушателей событий (Event Listener Adapter classes): MouseAdapter, KeyAdapter и WindowAdapter.

AWT обеспечивает интерфейс для разработки графических приложений, независимый от платформы и устройства. Эти приложения запускаются на всех ОС.

В AWT выделяют два типа GUI элементов: компоненты (Component) и контейнеры (Container). На рис. 5 представлена диаграмма классов AWT, на которой разделены эти две группы элементов.

Рис. 5. Диаграмма классов AWT

Понимание принципов функционирования библиотеки AWT необходимо для программирования на Java с использованием любой другой библиотеки ГИП, включая Swing. Но детальное описание AWT выходит за рамки данного учебного пособия. В данной главе акцент сделан на разработке с использованием Swing.

Технология разработки ГИП Swing основана на AWT. На рис. 6 представлена диаграмма классов, отражающая преемственность двух технологий.

Рис. 6. Связь AWT и Swing

Особенности библиотеки Swing:

1) Swing написан на «чистом» Java (pure Java);

2) компоненты Swing являются «легковесными», тогда как компоненты AWT – «тяжеловесные». Это означает, что компоненты Swing вообще не нуждаются в поддержке операционной системы и поэтому гораздо более стабильны, и быстры;

3) компоненты Swing поддерживают подключаемые вид и поведение (pluggable look-and-feel). Такое поведение компонентов реализовано на основе архитектурного подхода MVC;

4) в компоненты Swing встроена поддержка всплывающих подсказок, рамок, клавиатурных действий, средств для пользователей с ограниченными возможностями;

5) компоненты Swing – это компоненты JavaBeans (модель визуального программирования, основанная на компонентах);

6) приложения Swing используют классы AWT для обработки событий (пакет java.awt.event). Swing добавляет новые классы в пакет javax.swing.event, но они используются редко;

7) приложения Swing используют классы AWT для управления размещением компонентов (FlowLayout и BorderLayout пакета java.awt). При этом добавлены новые менеджеры размещения, такие как Springs, Struts, и BoxLayout (пакет javax.swing);

8) в Swing реализована двойная буферизация и оптимизирован механизм прорисовки компонентов.

9) в Swing реализована поддержка много документального интерфейса (JLayeredPane и JInternalFrame);

10) в Swing существенно расширен список поддерживаемых компонентов.

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

Описание и принципы работы с каждым из представленных компонентов представлены в документации Java. Перед рассмотрением отдельных компонентов пользовательского интерфейса, необходимо освоить работу с главным элементом графического пользовательского интерфейса – окном.

Рис. 7. Диаграмма классов Swing

Контейнеры высшего уровня. Контейнеры высшего уровня (top level containers) представляют собой окна операционной системы, в которых программист может размещать элементы пользо-вательского интерфейса. К контейнерам высшего уровня относятся окна JFrame и JWindow, диалоговое окно JDialog, а также апплет JApplet (не является окном, но предназначен для построения интерфейса в браузере).

Для добавления элементов в окно (например, добавление кнопки на JFrame) логично было бы использовать метод add(), но контейнеры высшего уровня не позволяют добавлять компоненты напрямую. Для выполнения подобных задач применяется специальная панель JRootPane, которая расположена внутри контейнера высшего уровня. Эта панель называется корневой панелью (root panel). Следует понимать, что корневая панель не является отдельным компонентом – она представляет собой набор слоев (панелей), каждый из которых отвечает за определенный функционал. JRoot-Pane содержит следующие слои (рис. 8):

Рис. 8. Структура JFrame

1. Многослойная панель JLayeredPane. Представляет собой совокупность слоев, в которых располагаются визуальные компоненты Swing. Каждый слой имеет свой идентификатор, и программист может создавать произвольное количество слоев и располагать в них свои элементы. Существуют стандартные (предопределенные слои), номера которых заданы идентификаторами.

2. Строка меню (menu bar). Строка меню также размещается в многослойной панели, в том же специальном слое FRAME_CONTENT_LAYER, и занимает небольшое пространство в верхней части окна, в длину равное размеру окна, ширина используемого пространства при этом зависит от самой строки меню и содержащихся в ней элементов. Корневая панель следит за тем, чтобы панель содержимого и строка меню не перекрывались. Если строка меню в контейнере высшего уровня не требуется, корневая панель использует все пространство окна для размещения панели содержимого.

3. Панель содержимого (content pane) – часть корневой панели, служащая для размещения компонентов пользовательского интерфейса программы. Она занимает большую часть пространства многослойной панели (за исключением того места, что занимает строка меню). Чтобы панель содержимого не закрывала добавляемые впоследствии в окно компоненты, многослойная панель размещает ее в специальном очень низком слое с названием. FRAME_CONTENT_LAYER, с номером -30000. Именно в панель содержимого следует добавлять все компоненты вашего пользовательского интерфейса, это основное отличие контейнеров высшего уровня Swing от их аналогов из AWT. Попытка добавить компоненты напрямую в контейнер (JFrame) высшего уровня Swing приведет к ошибке, так что программисту Java следует запомнить важный вызов:

getContentPane().add(Kомпонент);

Панель содержимого – это экземпляр панели JPanel.

4. Прозрачная панель (glass pane). Прозрачная панель используется в приложениях достаточно редко, поэтому по умолчанию корневая панель делает ее невидимой. Данный слой может использоваться для организации автоматизированного тестирования интерфейса приложения, а также для реализации различных анимационных эффектов.

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

Классы для представления окон. Окно с рамкой JFrame унаследовано от класса JWindow (в рамках данного курса не рассматривается) и представляет собой наиболее часто используемое в приложениях окно. Окна JFrame обладают рамкой (которая позволяет пользователям легко изменять их размер), заголовком с названием приложения (хотя можно оставлять этот заголовок пустым), иногда системным меню (позволяющим проводить манипуляции с этим окном) и кнопками для управления окном (чаще всего для его закрытия и свертывания). Именно класс JFrame применяется в подавляющем большинстве приложений для размещения компонентов пользовательского интерфейса.

Рассмотрим пример исходного кода, демонстрирующий создание окна:

Рис. 9. Исходный код приложения с ГИП

На рис. 10 показан результат работы программы.

Рис. 10. Окно приложения, демонстрирующее базовый функционал JFrame

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

Диалоговые окна могут быть модальными (modal), они запрещают всем остальным окнам приложения получать информацию от пользователя, пока тот не закончит работу с модальным диалоговым окном. Модальные диалоговые окна полезны в тех ситуациях, когда информация, получаемая от пользователя, коренным образом меняет работу приложения и поэтому до ее получения продолжение работы невозможно. Внешний вид диалоговых окон повторяет окна с рамкой JFrame, но обычно у них меньше элементов управления (чаще всего, имеется только кнопка закрытия окна) и отсутствует системное меню. Как правило, диалоговые окна всегда располагаются поверх основного окна приложения, напоминая о том, что необходимо завершить ввод информации.

Принципы работы с диалоговыми окнами JDialog схожи с основными операциями класса JFrame. При работе с диалоговыми окнами следует помнить, что они бывают модальными и немодальными. Рассмотрим пример (рис. 5.7):

Рис. 11. Исходный код создания диалоговых окон

Таким образом, очевидно, что работа с классами JDialog и JFrame отличается не значительно.

Использование менеджеров расположения. Поддержка менеджеров расположения встроена в базовый класс всех контейнеров java.awt.Container. Задать и получить расположение элементов можно методами setLayout() и getLayout(). В библиотеки существуют стандартные менеджеры расположения (семь различных классов), но если программист хочет расположить компоненты особенным образом, ему необходимо реализовать интерфейс LayoutManager.

Стандартные менеджеры расположения: FlowLayout, GridLay-out, BorderLayout, GridBagLayout, CardLayout, SpringLayout, Box-Layout. Рассмотрим наиболее простые менеджеры.

Полярное расположение BorderLayout позволяет создать простую структуру окна. При этом окно разбивается на четыре полярных области и одну область, заполняющую центр окна (рис. 12).

Рис. 12. Схема расположения областей менеджера BorderLayout

Добавление компонента в контейнер производится методом add() с дополнительным параметром, указывающим на место рас-положения.

1. Значение BorderLayout.NORTH или строка «North» – компонент располагается вдоль верхней (северной) границы окна и растягивается на всю его ширину (панель инструментов).

2. Значение BorderLayout.SOUTH или строка «South» – компонент располагается вдоль нижней (южной) границы и растягивается на всю ширину окна (строка состояния).

3. Значение BorderLayout.WEST или строка «West» – компонент располагается вдоль левой (западной) границы окна и растягивается на всю его высоту, однако при этом учитываются размеры северных и южных компонентов (они имеют приоритет).

4. Значение BorderLayout.EAST или строка «East» – компонент располагается вдоль правой (восточной) границы окна.

5. Значение BorderLayout.CENTER или строка «Center» – компонент помещается в центр окна, занимая максимально возможное пространство.

Пример использования расположения BorderLayout представлен на рис. 13.

Рис. 18. Листинг с использованием менеджера BorderLayout

На представленном фрагменте необходимо обратить внимание на строку 18, в которой получается объект панели содержимого. Именно на этом объекте вызываются методы add() в строках 21–25.

В строке 19 вызов метода setLayout() закомментирован. Этот метод устанавливает конкретный менеджер расположения, и все элементы, добавляемые на панель содержимого, будут расставлены в соответствии с данным менеджером расположения. В данном случае этот метод можно не использовать, так как BorderLayout – это менеджер расположения по умолчанию.

В строках 21–25 используется метод add(), в качестве второго параметра которого передается характер расположения элемента. Расположение можно определить, как строку: «NORTH», «West» и т. д. Но можно использовать предопределенные значения: Border-Layout.NORTH, BorderLayout.WEST. Очевидны преимущества второго подхода.

Результат выполнения программы представлен на рис. 19.

Рис. 19. Приложение с использованием BorderLayout

Последовательное расположение FlowLayout. Менеджер задает последовательное расположение компонентов, «стопкой» (вертикально или горизонтально). Класс FlowLayout имеет три перегруженные версии:

– без параметров (расположение по умолчанию);

– с заданием выравнивания FlowLayout(int align), где перемен-ная align может принимать значения FlowLayout.LEFT,

FlowLayout.RIGHT, FlowLayout.CENTER, FlowLayout.LEADING, или FlowLayout.TRAILING.

– с выравниваем и заданием расстояния между элементами FlowLayout(int align, int hdist, int vdist), где hdist и vdist – расстоя-ние между элементами, помещаемыми в контейнер, по горизонта-ли и вертикали соответственно.

Пример использования FlowLayout показан на рис. 20.

Рис. 20. Расположение элементов с использованием менеджера FlowLayout

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

Рис. 21. Приложение с использованием менеджера FlowLayout

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

Конструкторы менеджера расположения:

– конструктор без параметров GridLayout() – устанавливает один столбец и одну строку;

– конструктор GridLayout(int rows, int cols) с указанием коли-чества строк (rows) и количества столбцов (cols);

– конструктор GridLayout(int rows, int cols, int hdist, int vdist) – за-дает количество строк (rows) и столбцов (cols), а также горизонтальное (hdist) и вертикальное (vdist) расстояния между элементами.

Если вместо rows или cols передано значение 0, то предполагается, что возможно неограниченное количество строк или столбцов. Сетка будет увеличиваться динамически. Все параметры, задаваемые конструкторами можно изменить с помощью методов объекта GridLayout.

Пример использования менеджера показан GridLayout на рис. 22.

Рис. 22. Использование менеджера GridLayout

Результат работы программы представлен на рис. 23.

Рис. 23. Приложение с использованием менеджера GridLayout

Рассмотрение прочих менеджеров расположения выходит за рамки данного пособия. Необходимо отметить, что если программист намерен применить абсолютное позиционирование элементов, то следует использовать вызов setLayout(null).

Блочное расположение BoxLayout. Менеджер расположения, обладающий широкими одновременно возможностями Grid-BagLayout (сложного менеджера с большим количеством настроек) и BorderLayout (простого менеджера, возможности которого были рассмотрены ранее). Это относительно новый компонент (пакет javax.swing), который рекомендуется использовать для размещения компонентов в современных приложениях. Конструктору класса BoxLayout необходимо указать контейнер, в котором он будет применен, и характер расположения элементов (Y_AXIS – по вертикали; X_AXIS – по горизонтали). Пример использования Box-Layout представлен на рис. 24.

Рис. 24. Использование менеджера BoxLayout

В данном листинге видно, что конструктор BoxLayout отличается от конструкторов менеджеров расположения, рассмотренных ранее. Конструктору в качестве параметра передается контейнер, в котором будет применен данный менеджер.

В результате работы программы создаются две формы с различным расположением элементов (рис. 25).

Рис. 25. Приложение с использованием менеджера BoxLayout

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

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

ЗАКЛЮЧЕНИЕ

Развитие информационных технологий не только затрагивает аппаратные системы – происходит интенсивное развитие программных систем. Объектно-ориентированные технологии также быстро развиваются. Новые возможности, доступные в языках программирования Java и C#, увеличивают разницу между «новыми» языками программирования и «традиционными» языками ОП (C++). Появление таких инструментов, как делегаты, лямбда-выражения, объектно-реляционное отображение, распределенные объектные системы, развитые модели событий стимулировало бурное развитие новых паттернов проектирования и реинжиниринг существующих.

В сложном мире ОП необходимо хорошо ориентироваться. Для этого необходимо понимать принципы разработки приложений, такие как S.O.L.I.D. Современному программисту необходимо обладать обширными теоретическими знаниями в области паттернов проектирования, без которых невозможна разработка сложных коммерческих приложений.

Разработка графических приложений и веб-приложений представляет собой пример наиболее сложных областей. При проектировании, реализации, тестировании, отладке и сопровождении подобных объектных систем программист должен задействовать максимальный объем доступного инструментария: модульное тестирование, рефакторинг, методы разработки посредством тестирования и, конечно, большинство паттернов и принципов S.O.L.I.D.

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

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

СПИСОК ИСПОЛЬЗОВАННЫХ ИСТОЧНИКОВ

1. Шилдт Г. Java. Полное руководство / пер. с. англ. В. А. Коваленко. М.: ООО «И. Д. Вильямс», 2012. 1104 с.

2. Корнелл Г., Хорстманн К. С. Java. Библиотека профессионала: в 2 т. Т. 1. Основы / пер. с. англ. И. В. Берштейн. М.: ООО «И. Д. Вильямс», 2014. 864 с.

3. Корнелл Г., Хорстманн К. С. Java. Библиотека профессионала: в 2 т. Т.2. Расширенные средства / пер. с. англ. И. В. Берштейн. М.: ООО «И. Д. Вильямс», 2014. 864 с.

4. Троелсен Э. Язык программирования C# 5.0 и платфор-ма.NET 4.5. М.: Изд. «Издательский дом Вильямс». 2013. 1312 с.

5. Албахари Дж., Албахари Б. C# 5.0. Справочник. Полное описание языка. М.: ООО «И. Д. Вильямс». 2013. 1008 с.

6. Стиллмен Э., Грин Дж. Изучаем C#. СПб.: Питер. 2014. 816 с.

7. Флентов М. Библия C#. СПб.: БХВ-Петербург, 2011. 560 с.

8. Ватсон Б. С# 4.0 на примерах. СПб.: БХВ-Петербург, 2011. 608 с.

9. Буч Г. Объектно-ориентированный анализ и проектирование с примерами приложений. М.: ООО «И. Д. Вильямс», 2008. 720 с.

10. Петцольд Ч. Программирование для Microsoft Windows 8. СПб.: Питер. 2013 1008 с.

11. Гранд М. Шаблоны проектирования в Java / пер. с. англ. С. Беликовой. М.: Новое знание, 2004. 559 с.

12. Монахов В. Язык программирования Java и среда NetBeans. СПб.: БХВ-Петербург, 2011. 704 с.

13. Блох Дж. Java. Эффективное программирование / пер. с. англ. Е. Коротылева. М.: Лори, 2014. 461 с.

14. Блинов И., Романчик В. С. Java: методы программирования: уч.-мет. пособие. Минск: «Четыре четверти», 2013. 896 с.

15. Архангельский, А.Я. Программирование в Delphi 7 / А.Я. Архангельский. – М.: ООО «Бином-Пресс», 2003. – 1152 с.: ил. 6. Бабушкина, И.А. Практикум по объектно-ориентированному программированию / И.А. Бабушкина. - М.: Изд-во «БИНОМ. Лаборатория знаний», 2004. - 366 с.

16. Бадд, Т. Объектно-ориентированное программирование в действии: пер. с англ. / Т. Бадд. – СПб.: Питер, 1997. – 464 с.

17. Буч, Г. Объектно-ориентированный анализ и проектирование с примерами приложений на С++: пер. с англ. / Г. Буч. – 2-е изд. – М.: Бином, СПб.: Невский диалект, 1998. – 560 с.

18. Давыдова, Н.А. Программирование: учеб. пособие / Н.А. Давыдова, Е.В. Боровская. – М.: Бином, Лаборатория знаний, 2009. – 238 с.: ил. – (Педагогическое образование).

19. Дал, У. и др. Структурное программирование: пер. с англ. / У. Дал, Э. Дейкстра, К. Хоор. – М.: Мир, 1975. – 247 с.

20. Дарахвелидзе, П.Г. и др. Программирование в Delphi 7 / П.Г. Дарахвелидзе, Е.П. Марков. – СПб.: БХВ-Петербург, 2003. – 784 с.: ил.

22. Епанешников, А.М. Delphi 5. Язык Object Pascal: уч. пособие /А.М. Епанешников, В.А. Епанешников - М.: Диалог-МИФИ, 2000. – 381 с.

23. Кенту, М. Delphi 7: для профессионалов / М. Кенту. – СПб.: Питер, 2004. – 1101 с.: ил.

24. Конопка, Р. Создание оригинальных компонент в среде Delphi: пер. с англ. / Р. Конопка. – Киев.: НИПФ – «ДиаСофт ЛТД.», 1996. – 512 с.

25. Корняков, В.Н. Программирование документов и приложений MS Office в Delphi / В.Н. Корняков. – СПб.: БХВ-Петербург, 2005. – 496 с.: ил.

26. Лишер, Р. Секреты Delphi 2: пер. с англ. / Р. Лишер. – К.: НИПФ "ДиаСофтЛтд.", 1996. – 800 с.

27. Марченко А.И. Программирование на языке Object Pascal 2.0. - Киев: Юниор, 1998. - 304 с.

28. Мачто, Д. Delphi: пер. с англ. / Д. Мачто, Д.Р. Фолкнер. – М.: Бином, 1995. – 464 с.

29. Орлик, С.В. Секреты Delphi на примерах: Версии 1.0 и 2.0 / С.В. Орлик. – М.: Бином, 1996. – 316 с.

30. Сухарев, М.В. Основы Delphi. Профессиональный подход / М.В. Сухарев. – СПб.: Наука и Техника, 2004. – 600 с.: ил.

31. Фаронов, В.В. Delphi 3: Учебный курс / В.В. Фаронов. – М.: Нолидж, 1998. – 400 с.

32. Хьюз, Дж. Структурный подход к программированию: пер. с англ. / Дж. Хьюз, Дж. Мичтом. – М.: Мир, 1980. – 278 с.