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

Содержание:

ВВЕДЕНИЕ

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

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

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

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

Задачи исследования:

1. Обзор исторических предпосылок создания языков и методологий программирования.
2. Проведение классификации специфики языков программирования высокого уровня.
3. Анализ основных принципов и сущности методологии ООП.
4. Анализ возможностей современных языков программирования, которые основаны на реализации ООП парадигмы.
5. Разработка программного обеспечения на базе использования ООП.

В настоящее время исследованию специфики применения методологи ООП посвящено множество литературных источников. Много внимания к языкам программирования, реализующим ООП уделено в книгах В.В. Монахова, О.Л. Голициной, В.А. Камаева, Д. Рихтера, С.Синицина, И.А. Хахаева, К. Нейгела, Т. Пратта, Р. Себеста, А.А. Тюгашева и др. Специфика разработки различных программных приложений на базе использования языка программирования Jаva исследована и описана в трудах И. Портянкина, Р. Ларофе, П. Нимейера, Р. Седжвика, К.Сьерра, С. Хорстманна, Г.Корнелла и др. Проанализированные источники являются основой для применения полученных знаний на практике.

1. ИСТОРИЧЕСКИЕ АСПЕКТЫ ВОЗНИКНОВЕНИЯ ЯЗЫКОВ ПРОГРАММИРОВАНИЯ И ООП

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

Языки программирования - формальные знаковые системы, предназначенные для записи компьютерных программ. Языки программирования определяют набор лексических,  синтаксических и  семантических правил, определяющих внешний вид программы и действия, которые выполнит исполнитель (обычно — ЭВМ) под её управлением [1].

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

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

Компьютерная программа - это набор правил, посредством которых компьютер (ЭВМ) выполняет заданный вычислительный процесс, управляя различными операционными объектами [18].

Структурная схема классификации языков программирования приведена на рис.1.

Рисунок 1 – Структурная схема классификации языков программирования

1.1. Исторические предпосылки создания языков программирования и методологий программирования

Первые технические идеи, которые привели к разработке вычислительных цифровых машин, сформированы еще в начале 20-х годов девятнадцатого века Бэббиджем. Главной была мысль о возможности предварительной фиксации перечня операций вычислительной машины для дальнейшей реализации вычислений в автоматическом режиме, т.е. в виде программы [17]. Не смотря на то, что использованная Бэббиджем реализация данной мысли на базе перфокарт, которые в свое время были придуманы изобретателем из Франции Мари-Жаккаром, технически давно устарела и имеет мало общего с современными методами обеспечения хранения данных в электронных вычислительных машинах (ЭВМ), концептуальный принцип остался прежним [18]. Можно утверждать, что с данного момента ведет свой отсчет эра программирования [3].

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

Принципиальным этапом в развитии языков программирования явилось создание системы кодирования команд ЭВМ посредством использования специальных символов. Данная схема была предложена сотрудником Пенсильванского университета – Моучли [9].

В процессе работы на ЭВМ «Марк-1» последовательница Моучли - Хоппер столкнулась с многими техническими проблемами управления данными, однако, эксперименты Хоппер и ее команды способствовали развитию методов решения существующих проблем (например, были разработаны концепции использования подпрограмм). Также, Хоппер, совместно с коллегами впервые ввела такое понятие осуществления техники программирования как программная отладка. Необходимость в разработке такого механизма возникла еще в 1945 году, когда произошла аварийная остановка работы ЭВМ «Марк-1». В процессе диагностики была выявлена неисправность одного из управляющих реле, работа которого была заблокирована бабочкой-мотыльком (bug). После этого случая стал широко применяться термин «отладка» или debuging для обозначения технического процесса проведения тестирования возможных неисправностей в разработанной программе [10].

В конце 40-х годов 20 века машинный код являлся, фактически, единственным способом организации взаимодействия человека-пользователя с ЭВМ. Важнейшим достижением разработчиков языков программирования тех времен являлась реализация алгоритмов и механизмов использования ЭВМ для автоматической интерпретации языка программирования в машинный код [2].

В 1949 году, некий Моучли разработал информационную систему, которую назвал «Short Code». Фактически, данная система представляла собой один из первых высокоуровневых языков программирования. Данная система предоставляла возможности описания задачи в виде перечня различных математических формул, после чего, на базе использования специальной таблицы соответствия, производился перевод символов формул в необходимые двухлитерные коды.

После этого специальный программный модуль конвертировал полученные коды непосредственно в машинный двоичный код. Фактически, данная система являлась первым примитивным интерпретатором программного кода [14].

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

Уже в 1954 году команда Хоппер реализовала систему, которая одновременно интегрировала компилятор и язык программирования, которую назвали MATH-MATIC. Затем была поставлена задача реализовать подобную систему, которая поддерживала бы написание программ на близком к родному, английскому, языку исследователей команды Хоппер. Таким образов в 1958 году появился язык программирования и компилятор, который поддерживал написание программ в таком виде, его назвали FLOW-MATIC [17].

Данный язык программирования стал первым языком, который получил применение в решении задач обработки различных коммерческих данных. Развитие данного языка привело к разработке популярного в свое время бизнес-ориентированного зыка COBOL - Common Business Oriented Language. Существенный вклад в разработку данного языка сделала также команда Хоппер [13].

Уже с начала 60-х годов ХХ века популярность языков программирования начинает стремительно возрастать и общий прогресс в разработке методов и средств программирования с использованием ЭВМ набирается все большие обороты. При этом, вследствие развития технологий постоянно уменьшается использование подхода к написанию программ в машинных командах.

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

Первым и из таких языков стал FORTRAN (FORmula TRANslator, т.е переводчик формул), который был разработан командой программистов из молодой фирмы IBM [9].

С данного языка наступает эра развития и совершенствования языков программирования высокого уровня [16].

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

Были разработаны три основополагающих принципа (подробнее будут рассмотрены во второй главе) того, что потом стало называться объектно-ориентированным программированием (ООП) [5]:

• наследование;
• инкапсуляция;
• полиморфизм.

 Результатом их первого применения стал язык Симула-1 (Simula-1), в котором был введен новый тип – объект. В описании этого типа одновременно указывались данные (поля) и процедуры, их обрабатывающие – методы. Родственные объекты объединялись в классы, описания которых оформлялись в виде блоков программы. При этом класс можно использовать в качестве префикса к другим классам, которые становятся в этом случае подклассами первого [3].

 Впоследствии Симула-1 был обобщен, и появился первый универсальный ООП-ориентированный язык программирования – Симула-67 (67 – по году создания).

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

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

1.2. Классификация и специфика языков программирования высокого уровня

К ранним высокоуровневым языкам программирования высокого уровня исторически принято относить следующие [3].

1.Фортран, использовался преимущественно для написания программ, которые выполняли научные и математические расчеты.

2. Алгол – один из первых коммерческих языков программирования, применялся для решения различных экономических задач).

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

4. Си – язык разработки первых сетевых протоколов и операционных систем, популярных в ряде отраслей и в настоящее время.

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

Данные высокоуровневые языки программирования являлись машинно–независимыми, в силу их ориентации на систему операндов, которые являются характерными для формализации записей имплементированных алгоритмов. Не смотря на это преимущество, в 60-х годах было выявлено, что программы, которые разработаны на базе использования языков программирования высокого уровня, занимают существенно больше оперативной памяти ЭВМ, что обуславливает меньшую скорость выполнения по сравнению с программами, которые были реализованы на машинных языках [13].

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

Согласно специфике использования высокоуровневых языков программирования используется три типа трансляторов [17]: 

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

2. Компилятор – это транслятор, который осуществляет преобразование всей программы в отдельный модуль машинного языка, а затем программа записывается непосредственно в оперативную или постоянную память ЭВМ и выполняется.

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

Генеалогическое дерево языков программирования приведено на рис.2 [5].

Рисунок 2 - Генеалогическое дерево исторического развития языков программирования

Все языки программирования часто классифицируют по таким поколениям [14]:

– первое поколение: применение на ЭВМ первого поколения с машинно–ориентированным использованием и ручным процессом управлением памятью;

– второе поколение: применение автокодов или мнемонических символов для представления команд программы;

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

– четвертое поколение: высокоуровневые языки программирования, использованные для разработки специализированных прикладных программ и приложений, которые поддерживали механизмы использования систем управления базами данных [10];

– пятое поколение: объектно–ориентированные, декларативные и визуальные высокоуровневые языки программирования. Данные языки применяются в настоящее время и используются для разработки клиент-серверных приложений, мобильных систем и распределенных веб-ресурсов. Примерами таких языков являются Си++, Java, C#, Visual Basic, Delphi.

Языки программирования часто классифицируют на процедурные и декларативные [16].

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

Среди таких языков выделяют структурные и операционные языки. В структурных языках запись целых алгоритмических структур (ветвление, циклы и др.) выполняются одним оператором. В операционных языках для решения данной задачи применяется уже несколько операций. Исторически, структурными языками являются Паскаль, Ада, Си. Операционными являются Фортран, Фокал, Бейсик [18].

К декларативным языкам программирования часто относят логические и функциональные языки.

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

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

Наиболее популярным в настоящее время классом языков программирования высокого уровня является объектно–ориентированные языки. Данные языки чаще всего не используются для описания детальной последовательности действий выполнения и решения задачи, однако, они включают соответствующие механизмы и содержат некоторые элементы процедурного программирования. За счет использования методов, классов, полей и принципов объектно-ориентированной парадигмы программирования данные языки позволяют решать широкий круг практических задач. Первым объектно-ориентированным языком принято считать язык Simula, который был создан еще в 1960-х годах Нигаардом и Далом [9].

В настоящее время наиболее востребованными языками программирования высокого уровня, поддерживаемыми объектно-ориентированную методологию, являются C, C#, Java и др (рис.3).

Рисунок 3 – Статистика востребованности современных языков программирования высокого уровня [10]

Выводы по главе 1

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

Рассмотрены исторические аспекты возникновения языков программирования и объектно-ориентированной методологии разработки программного обеспечения. Рассмотрена классификация и специфика языков программирования высокого уровня в их историческом разрезе. Приведено генеалогическое дерево их исторического развития с 1960 по 2000 годы.

Приведена диаграмма востребованности современных языков программирования на практике.

2. СПЕЦИФИКА МЕТОДОЛОГИИ ООП В СОВРЕМЕННЫХ ЯЗЫКАХ ПРОГРАММИРОВАНИЯ

2.1 Сущность методологии ООП

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

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

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

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

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

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

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

Рисунок 4 – Взаимодействие объектов и их структура в ООП

Таким образом, объект в выделенном адресном пространстве системы, создается при инициализации формирования отдельного экземпляра класса, а также в случае копирования существующего прототипа. Типичным примером является запуск итоговых результатов выполненного процесса компиляции, за которым следует связывание выполняемого кода [5].

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

Для ООП характерным является использование следующих принципов или концепций (рис.5).

Рисунок 5 – Принципы ООП

Существует 3 главных принципа парадигмы ООП [16].

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

Пример схемы отображения принципа инкапсуляции парадигмы ООП приведена на рис.6 [9].

Абстрагирование в данном случае позволяет обеспечить описание комплекта наиболее значимых характеристик объекта, а незначимые и неприоритетные характеристики объекта отбрасываются. Таким образом, абстракция представляет собой формализованное описание набора всех значимых параметров и характеристик объекта [2].

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

Класс, от которого производится наследование нового класса, называют родителем, базовым или суперклассом [18].

Рисунок 6 – Пример схемы отображения принципа инкапсуляции ООП

Пример иллюстрации принципа наследования в парадигме ООП приведен на рис.7 [19]. Класс Program является родителем для класса MyCar, который в свою очередь выступает родителем для класса MySportCar, все они могут дополнять описанные методы суперкласса Program новыми функциональными возможностями.

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

В настоящее время количество высокоуровневых прикладных языков программирования, которые поддерживают парадигму ООП, является наиболее широким. Каждый язык программирования реализует ООП по-разному, однако принципы ООП во всех языках, в целом, одинаковы [1].

Рисунок 7 – Пример иллюстрации принципа наследования в парадигме ООП

В предметной области, которая касается непосредственно системного программирования, при этом, и в настоящее время активно применяется процедурная парадигма программирования [5].

Чаще всего данная парадигма находит свое воплощение в средствах языка C или С++, которые обладают максимальной гибкостью обработки данных для микроконтроллеров и других устройств низкого архитектурного уровня [3].

2.2 Анализ современных языков программирования, базирующихся на методологии ООП

1. Java. Это популярный высокоуровневый язык программирования, который был выпущен известной ИТ компанией Sun Microsystems еще в 1995 году. В настоящее время разработкой языка Java занимается корпорация Oracle. Синтаксис данного языка во многом похож на язык C++, на котором Java и был изначально разработан. Разрабатываемые Java приложения компилируются в отдельный байт-код (формат .class), который при выполнении интерпретируется JVM (виртуальной машиной Java) для конкретной аппаратно-программной платформы или операционной системы [4].

В Java была взята за основу модель объекта из С ++ со значительной модификацией. Отсутствие возможностей множественного наследования, деструкторов и возможностей ручного управления указателями к ячейкам памяти, все это является характерными чертами языка Java. Также, устранена возможность происхождения различных конфликтных ситуаций, по причине ошибок в коде программиста, а также обеспечена большая гибкость процесс разработки классов и объектов [6].

Некоторые функции, которые в языке C ++ обычно осуществлялись разработчиками вручную теперь выполняет JVM (например сборка мусора механізмом Garbage Collector). Это приводит к ряду особенностей языка, например, в силу того, что Java разрабатывался как кроссплатформенный язык разработки, он обладает меньшими возможностями для работы с аппаратным обеспечением на низком уровне. Но, для обхода этого недостатка языка существуют механизмы интеграции отдельных модулей низкоуровневого управления, которые могут быть написаны на других языках (ассемблер, С++ и др.) [8].

При создании Java изначально были сформулированы такие принципы [14]:

- сам синтаксис должен быть максимально простым, гибким, удобным и привычным пользователю-разработчику;

- высокая производительность и безопасность процесса разработки и реализации исполняемых приложений;

- кроссплатформенность по принципу “Once Write –Anywhere Use”;

- поддержка масштабируемости и мультизадачности посредством возможности создания параллельных процессов и потоков [23].

Кроссплатформенность достигается путем компиляции изначального Java-кода (формат .java) в байт-код (.class), представляющего собой набор упрощенных команд. После этого разработанное приложение может быть выполнено на любой поддерживаемой платформе, т.е. на платформе, которая имеет установленную JVM, способную интерпретировать байткод в код, учитывающий специфику конкретной ОС и процессора. В настоящее время JVM существуют для практически всех операционных систем (Linux, Windows, Mac и др.) и процессоров [15].

Первым и самым главным преимуществом использования байт-кода является портативность. Т.е. байт-код переносится на любую платформу и запускается без установки, достаточно просто наличие JVM. При этом, недостатком является необходимость выделения дополнительных вычислительных ресурсов на интерпретацию, т.е. мощности процессора и оперативной памяти задействуются в большем объеме. В связи с этим некоторые считают, что Java является достаточно медленным языком разработки [19].

В Java практически все структуры данных являются объектами. Исключением являются такие примитивные типы данных, как целочисленные (int), символы (char), логический тип данных (boolean) и др. Также, в Java все объекты являются производными от самого главного объекта (Object), который является их потомком, посредством которого обеспечивается их базовое поведение и все основные свойства [14].

В Java возможно единичное наследование, что позволяет исключить возникновение конфликтов между различными членами класса, которые могут быть наследованы от нескольких родителей, что затрудняет их однозначную идентификацию [21].

2. С#. Данный язык программирования реализует компонентно-ориентированный подход в программировании приложений, что позволяет снизить машинно-архитектурную зависимость полученного кода, благодаря чему достигается высокая степень переносимости и повторного использования кода. Преимущества языка: включает расширенную и гибкую поддержку событийно-ориентированного программирования, эффективно интегрируется с существующими продуктами от Microsoft. Главными недостатками языка является довольно сложный синтаксис и не высокая, в сравнении с С++, производительность [7].

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

При разработке языка C#, его создатели основывались на существующих преимуществах других языков, такиз как C++, C, Java. В результате работы по созданию данного языка программирования высокого уровня получился удобный и гибкий язык, который по функциональным возможностям практически не уступает языку С++, однако существенно существенно повышает эффективность и скорость разработки программ [2].

В качестве среды разработки для языка С# чаще всего применяется IDE Visual Studio [12].

Python. Это современный интерпретируемый кроссплатформенный язык программирования. Как и Java он прост и гибок в отладке, однако не обладает высоким быстродействием и низкой требовательностью к вычислительным возможностям компьютера. Характерными особенностями данного языка являются следующими [16]:

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

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

3. Встроенная поддержка Unicode.

4. Поддержка парадигмы ООП.

5. Поддержка автоматической процедуры по «сборке мусора», т.е. в языке Python, как и в Java, отсутствуют деструкторы.

6. Гибкий автоформатируемый синтаксис, что обеспечивает читаемость кода.

7. Поддержка большого количества модулей и библиотек, среди которых есть множество «родных», т.е идущих «в коробке» при установке языка, так и от сторонних разработчиков. В ряде случаев для написания кода нет необходимости писать все с нуля, а достаточно найти подходящие библиотеки и модули, разобраться в их методах и подключить в свой проект. Т.е. появляется возможность работы с уже готовыми элементами, которые реализуют готовую функциональность и лишь комбинировать их [17].

8. Кроссплатформенность. Т.е. программное обеспечение, которое написано на языке Python, может использовать на любой операционной системе, где установлен данный интерпретатор. В редких случаях возможны ошибки, как правило, возникающие из-за различий в синтаксисе версий языка. Решение данных проблем обеспечивается путем использования регламентированной справочной документации, имеющейся на официальных сайтах поддержки данного языка программирования в большом количестве [5].

Выводы по главе 2

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

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

3. РАЗРАБОТКА ПРОГРАММНОГО ОБЕСПЕЧЕНИЯ С ИСПОЛЬЗОВАНИЕМ ООП

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

3.1 Разработка проекта системы и ее основных классов

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

Класс - сущность, инкапсулирующая данные. Согласно традиционным подходам данные располагаются в базе данных, а обработкой их поведения занимается программа [2].

Диаграмма классов разработанной системы приведена на рис.8.

В основном на диаграмме можно выделить 3 вида классов:

• Классы, которые взаимодействуют с базой данных - Goods, Stores, Data, HibernateUtil;

• Классы, которые отвечают за отображение программы - FXMLDocument;

• Классы, которые следят за действиями пользователя с программой и выполняют отдельные функции - FXMLDocumentController.

Также есть класс, который отвечает за алгоритм расчетов - Logics. В нем к основным методам относятся следующие: sort (), pack () draw (). Метод sort () отвечает за сортировку элементов по выбранным критериям, таким как масса за варианты, которыми можно поставить элемент. Метод pack () отвечает за само расположение. Метод draw () отвечает за отображение элементов, где задаются их свойства: цвет, окончательные координаты, вид элемента, возвращает массив из элементов и используются в классе-отображении программы.

Отдельно выделяется класс HibernateUtil. Он используется для работы Hibernate. С помощью него с базой данных взаимодействуют другие классы (Goods, Stores), которые имеют те же поля, что в таблицах БД, методы get-тер и set-тер этих полей, и конструкторы.

В целом можно сказать, что программа разработана, соблюдая архитектурного шаблона MVC (Model-View-Controller).

Рисунок 8 – Разработанная диаграмма классов системы

Структура программных файлов проекта разработана с использованием системы автоматической сборки Java-приложения Ant, показано на рис. 9. Проект создан в среде разработки Netbeans [6], использована библиотека JavaFX Проект состоит из двух пакетов: Default и Main, содержащие соответствующие программные файлы и классы.

Рисунок 9 – Структура программных файлов проекта

Перечень базовых функциональных методов, компонентов и структур данных показан на рис. 10. Все они разработаны на базе применения методов ООП.

Рисунок 10 – Перечень базовых функциональных методов, компонентов и структур данных

Наиболее важными являются следующие методы контроллера:

1. add, addGood, addStore- используются для придания новой записи в соответствующей таблице БД.

2. deleteGood, deleteContainer, deleteStore - используются для удаления записи из соответствующей таблицы БД.

3. changeGood, changeStore - используются для изменения записи в соответствующей таблице БД.

4. exportGoods, exportStores, exportAll - используется для экспорта данных в таблицы Excel.

5. initData - используется для инициализации в начале программы данных в таблице с БД.

Из важных компонентов можно выделить следующие:

1. goodsView, storesView - компоненты таблиц.

2. goodsData, storesData - оболочки данных, хранящихся в таблицах.

3. containersList - компонент перечня контейнеров.

4. idGood, idStore, massGood. lengthGood, countGood, addressStore, idStore, universalStore - компоненты колонок в таблицах.

3.2 Разработка интерфейса системы

Интерфейс вкладки «Склад» разработанной системы приведен на рис.11.

Рисунок 11 – Интерфейс вкладки «Склад» разработанной системы

Он состоит из следующих компонентов обеспечения пользовательских функций по обработке информации [23] в соответствующей таблице созданной базы данных:

1. TableView - отражает соответствующие поля таблицы «Товары», предусматривает функции по изменению существующих записей и ввода данных по новым созданным записям.

2. TextField - отвечает за выполнение поиска данных по таблице БД.

3. Button - инициирует функции поиска данных, добавления новой записи или удаления существующей записи и экспорта данных в табличного редактора Excel [22].

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

Рисунок 12 – Пример фильтрации данных по названию

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

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

Рисунок 13 – Пример работы функциональной возможности по выбору типа товаров

Интерфейс вкладки «Контейнеры» для управления данными из типов контейнеров показано на рис.14.

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

С выпадающего меню слева, как показано на рис. 15 можно выбрать тип и нажать на кнопку «Добавить».

При нажатии кнопки «Удалить» запись удаляется..

Рисунок 14 – Интерфейс вкладки «Контейнеры» для управления данными из типов контейнеров

Рисунок 15 – Функциональная возможность избрания и просмотра типов контейнеров

Интерфейс вкладки «Склады» разработанной системы показано на рис. 16. Как и в вкладке «Товары», в таблице есть возможность редактировать колонки. Диалоговое окно для выбора пути экспорта данных, которое появляется при нажатии кнопки «Экспорт в Excel», показано на рис. 17. В окне надо ввести название файла и выбрать кнопку «Сохранить».

Рисунок 16 – Интерфейс вкладки «Склады» разработанной системы

Рисунок 17 – Диалоговое окно для выбора пути экспорта данных

Результат экспорта данных по соответствующей таблице в табличного редактора MS Excel показано на рис. 18. Эта возможность предусмотрена для всех таблиц

Рисунок 18 – Результат экспорта данных по соответствующей таблице в табличного редактора MS Excel

Интерфейс вкладки «Упаковать» разработанной системы показан на рис. 19.

Рисунок 19 – Інтерфейс вкладки «Упакувати» розробленої системи

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

Также надо определить цвет, который будет использован при визуализации.

Пример добавления товаров для упаковки показано на рис. 20. Из списка с выбранными товарами можно удалить товары, если они выбраны ошибочно.

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

Во втором пункте можно выбрать контейнеры, которые желательны или полностью передать выбор алгоритма программы, выбрав флажок.

После окончательного выбора товаров и контейнеров надо нажать кнопку «Рассчитать».

Тогда появляется 3D-визуализация контейнера. С помощью слайдеров можно поворачивать модель, как показано на рисунке 21.

Пример визуального размещения товаров в контейнере показано на рисунке 22.

Рисунок 21 – Пример добавления товаров для упаковки

Рисунок 22 – Пример визуального размещения товаров в контейнере

Выводы по главе 3

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

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

ЗАКЛЮЧЕНИЕ

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

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

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

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

1. Проведен обзор исторических предпосылок создания языков и методологий программирования.
2. Проведена классификация и описание специфики языков программирования высокого уровня.
3. Выполнен анализ основных принципов и сущности методологии ООП.
4. Проведен анализ возможностей современных языков программирования, которые основаны на реализации ООП парадигмы.
5. Разработано программное обеспечение на базе использования ООП.

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

БИБЛИОГРАФИЯ

1. Голицына О.Л., Партыка Т.Л., Попов И.И. Языки программирования Учебное пособие. – М.: Форум, 2011. – 400 с.
2. Забудский Е.И. Объектно-ориентированный анализ и программирование на языке C# — М.: Кафедра ОИиППО ГУ-ВШЭ, 2012. — 705 с.
3. Камаев В.А., Костерин В.В. Технологии программирования. – М.: Высш. шк., 2006. – 454 с.
4. Лафоре Р. Структуры данных и алгоритмы в Java. Классика Computers Science.— СПб.: Питер, 2013. — 704 с.
5. Могилев А.В., Листрова Л.В. Методы программирования. Компьютерные вычисления. – СПб.: БХВ-Петербург, 2013. — 320 с.
6. Монахов В.В. Язык программирования Java и среда NetBeans. – СПб.: БХВ-Петербург, 2011. – 704 с.
7. Нейгел К., Ивьен Б., C# 5.0 и платформа .NET 4.5 для профессионалов. М.: Академия, 2014. – 1440 с.
8. Нимейер П. Программирование на Java. – Москва: Эксмо, 2014. – 1216 с.
9. Орлов С.А. Теория и практика языков программирования. – СПб.: Питер, 2014. – 690 с.
10. Пратт Т. Языки программирования. Разработка и реализация. – М.: Мир, Москва, 2011. – 574 с.
11. Портянкин И. Swing. Эффективные пользовательские интерфейсы. СПб.: Питер, 2010 . – 337 с.
12. Рихтер Д. Программирование на платформе Microsoft .NET Framework 4.0 на языке C#. – СПб.: Питер, 2012. – 720 с.
13. Себеста Р. Основные концепции языков программирования. Concepts of Programming Languages. – М.: Эксмо, 2011. – 512 с.
14. Седжвик Р., Уэйн К.. Алгоритмы на Java. – М.: ООО “И.Д. Вильямс”, 2013. – 848 с.
15. Сьерра К. Изучаем Java. – М.: Эксмо, 2014. – 708 с.
16. Синицын С. Программирование на языке высокого уровня. – СПб.: Академия, 2011. – 400 с.
17. Тюгашев А.А.. Основы программирования. – СПб.: Университет ИТМО, 2016. – 160 с.
18. Хахаев И. А. - Практикум по алгоритмизации и программированию. – М.: Альт Линукс, 2010. – 126 с.
19. Хорстманн С., Корнелл Г. Java. Библиотека профессионала. – М.: ООО “И.Д. Вильямс”, 2014. – 864 с.
20. Шилдт Г. Java. Полное руководство, 8-е изд. – М.: ООО “И.Д. Вильямс”, 2012. – 1104 с.
21. Шилдт Г. Swing: руководство для начинающих. – М.: ООО “И.Д. Вильямс”, 2011. – 704 с.
22. Эванс Б., Вербург М. Java. Новое поколение разработки. – СПб.: Питер, 2014. — 560 с.
23. Эккель Б. Философия Java. – СПб.: Питер, 2015. – 1168 с.

ПРИЛОЖЕНИЕ

Data.java

package main;

import java.util.Iterator;

import java.util.List;

import javax.faces.bean.ManagedBean;

import javax.faces.bean.SessionScoped;

import org.hibernate.Query;

import org.hibernate.Session;

/**

*

* @author Aline

*/

@ManagedBean

@SessionScoped

public class Data implements AutoCloseable{

private final Session session;

public Data(){

session = HibernateUtil.getSessionFactory().openSession();

}

public List loadGoodsList(){

return session.createCriteria(Goods.class).list();

}

public List loadContainersList(){

return session.createCriteria(Containers.class).list();

}

public List loadStoresList(){

return session.createCriteria(Stores.class).list();

}

public List loadListofgoods(int number){

session.beginTransaction();

Query query = session.createQuery("from Listofgoods where idContainer = :number");

query.setParameter("number", number);

List l = query.list();

Iterator<Listofgoods> it = l.iterator();

while (it.hasNext()) {

Listofgoods tmp = it.next();

query = session.createQuery("select g.name from Goods g where g.idGood = :idGood");

query.setParameter("idGood", tmp.getIdGood());

if (!query.list().isEmpty()) tmp.setName(query.list().get(0).toString());

}

session.getTransaction().commit();

return l;

}

public List loadTypesList(){

session.beginTransaction();

Query query = session.createQuery("SELECT t.type FROM Types t");

session.getTransaction().commit();

return query.list();

}

public List loadStoreTypesList(int idStore){

session.beginTransaction();

Query query = session.createQuery("SELECT t.type FROM Listoftypes l, Types t WHERE t.idType = l.idType and l.idStore = :id");

query.setParameter("id", idStore);

session.getTransaction().commit();

return query.list();

}

public List loadContainertypesList(){

session.beginTransaction();

Query query = session.createQuery("SELECT c.containertype FROM Containertype c");

session.getTransaction().commit();

return query.list();

}

public void addGood(Goods g){

session.beginTransaction();

session.save(g);

session.getTransaction().commit();

}

public int addContainer(Containers c){

session.beginTransaction();

session.save(c);

session.getTransaction().commit();

return c.getIdContainer();

}

public void addStore(Stores s){

session.beginTransaction();

session.save(s);

session.getTransaction().commit();

}

public void deleteGood(int id){

session.beginTransaction();

session.delete(session.get(Goods.class, id));

session.getTransaction().commit();

}

public void deleteContainer(int id){

session.beginTransaction();

session.delete(session.get(Containers.class, id));

session.getTransaction().commit();

}

public void deleteStore(int id){

session.beginTransaction();

session.delete(session.get(Stores.class, id));

session.getTransaction().commit();

}

public void updateGood(Goods g){

session.beginTransaction();

session.update(g);

session.getTransaction().commit();

}

public void updateStore(Stores s){

session.beginTransaction();

session.update(s);

session.getTransaction().commit();

}

@Override

public void close(){

session.close();

HibernateUtil.getSessionFactory().close();

}

}

HibernateUtil.java

package main;

import org.hibernate.cfg.AnnotationConfiguration;

import org.hibernate.SessionFactory;

public class HibernateUtil {

private static final SessionFactory sessionFactory;

static {

try {

// Create the SessionFactory from standard (hibernate.cfg.xml)

// config file.

sessionFactory = new AnnotationConfiguration().configure().buildSessionFactory();

} catch (Throwable ex) {

// Log the exception.

System.err.println("Initial SessionFactory creation failed." + ex);

throw new ExceptionInInitializerError(ex);

}

}

public static SessionFactory getSessionFactory() {

return sessionFactory;

}

}

Main.java

package main;

import javafx.application.Application;

import javafx.application.Platform;

import javafx.event.EventHandler;

import javafx.fxml.FXMLLoader;

import javafx.scene.Parent;

import javafx.scene.Scene;

import javafx.stage.Stage;

import javafx.stage.WindowEvent;

public class Main extends Application {

@Override

public void start(Stage stage) throws Exception {

Parent root = FXMLLoader.load(getClass().getResource("FXMLDocument.fxml"));

Scene scene = new Scene(root);

stage.setTitle("Система разделения грузов");

stage.setScene(scene);

stage.show();

stage.setOnCloseRequest(new EventHandler<WindowEvent>() {

@Override

public void handle(WindowEvent t) {

Platform.exit();

System.exit(0);

}

});

}

/**

* @param args the command line arguments

*/

public static void main(String[] args) {

launch(args);

}

}

Logic.java

package main;

import java.util.List;

import javafx.scene.paint.Color;

import javafx.scene.paint.PhongMaterial;

import javafx.scene.shape.Box;

import javafx.scene.shape.DrawMode;

/**

*

* @author Aline

*/

class Element{

String name;

double mass;

int width, height, depth;

String contType;

String colour;

int variants;

int x = 1000000, y = 1000000, z = 1000000;

public Element(String name, double mass, int width, int depth, int height, String contType, String colour){

this.name = name;

this.mass = mass;

this.width = width;

this.height = height;

this.depth = depth;

this.contType = contType;

this.colour = colour;

}

}

public class Logic {

Element[] elements;

int contHeight = 300;

int contDepth = 300;

int contWidth = 300;

int[][][] container = new int[contHeight][contDepth][contWidth];

public void start(List list){

int tmp = 0;

for(int i = 0; i < list.size(); i++){

tmp += Integer.parseInt(list.get(i).toString().split(", ")[1].split(" ")[0]);

}

elements = new Element[tmp];

int k = 0;

for(int i = 0; i < list.size(); i++){

String[] temp = list.get(i).toString().split(", ");

String[] temp2 = temp[3].split("x");

for(int j = 0; j < Integer.parseInt(temp[1].split(" ")[0]); j++)

elements[k++] = new Element(temp[0], //name

Double.parseDouble(temp[2].split(" ")[0]), //mass

Integer.parseInt(temp2[0]), //width

Integer.parseInt(temp2[1]), //depth

Integer.parseInt(temp2[2]), //height

temp[4], //contType

temp[5]); //colour

}

setVariants();

sort();

pack();

}

public void setVariants(){

for (Element element : elements) {

int variantsPlacement = 0;

if(element.width <= contWidth && element.height <= contHeight && element.depth <= contDepth)

variantsPlacement++;

if(element.width <= contWidth && element.depth <= contHeight && element.height <= contDepth)

variantsPlacement++;

if(element.height <= contWidth && element.width <= contHeight && element.depth <= contDepth)

variantsPlacement++;

if(element.height <= contWidth && element.depth <= contHeight && element.width <= contDepth)

variantsPlacement++;

if(element.depth <= contWidth && element.height <= contHeight && element.width <= contDepth)

variantsPlacement++;

if(element.depth <= contWidth && element.width <= contHeight && element.height <= contDepth)

variantsPlacement++;

element.variants = variantsPlacement;

}

}

public void sort(){

boolean swapped = true;

int j = 0;

Element tmp;

while (swapped) {

swapped = false;

j++;

for (int i = 0; i < elements.length - j; i++) {

int volume1 = elements[i].width * elements[i].height * elements[i].depth;

int volume2 = elements[i + 1].width * elements[i + 1].height * elements[i + 1].depth;

if (volume1 < volume2) {

tmp = elements[i];

elements[i] = elements[i + 1];

elements[i + 1] = tmp;

swapped = true;

}

if (volume1 == volume2)

if (elements[i].variants > elements[i + 1].variants){

tmp = elements[i];

elements[i] = elements[i + 1];

elements[i + 1] = tmp;

swapped = true;

}

if (elements[i].mass > elements[i + 1].mass){

tmp = elements[i];

elements[i] = elements[i + 1];

elements[i + 1] = tmp;

swapped = true;

}

}

}

}

public void pack(){

int number = 0;

while (number < elements.length){

int cartI = 0, cartJ = 0, cartK = 0;

int h = elements[number].height;

int d = elements[number].depth;

int w = elements[number].width;

boolean end = false;

for (int i = 0; i < contHeight; i++){

for (int j = 0; j < contDepth; j++){

for (int k = 0; k < contWidth; k++){

// if the coordinate is empty

if (container[i][j][k] == 0){

int tmp = 1;

while (tmp <= 3){

switch(tmp){

case 1:

elements[number].height = h;

elements[number].depth = d;

elements[number].width = w;

break;

case 2:

elements[number].height = h;

elements[number].depth = w;

elements[number].width = d;

break;

case 3:

elements[number].height = d;

elements[number].depth = h;

elements[number].width = w;

break;

case 4:

elements[number].height = d;

elements[number].depth = w;

elements[number].width = h;

break;

/*case 5:

elements[number].height = w;

elements[number].depth = h;

elements[number].width = d;

break;

case 6:

elements[number].height = w;

elements[number].depth = d;

elements[number].width = h;

break;*/

}

boolean fit = true;

// if we place element in this coordinate, does it fit fully?

if (i + elements[number].height > contHeight

|| j + elements[number].depth > contDepth

|| k + elements[number].width > contWidth)

fit = false;

// does it fit in height?

if (fit != false)

for (int t = i; t < i + elements[number].height; t++)

if (container[t][j][k] != 0){fit = false; break;}

// does it fit in depth?

if (fit != false)

for (int t = j; t < j + elements[number].depth; t++)

if (container[i][t][k] != 0){fit = false; break;}

// does it fit in width?

if (fit != false)

for (int t = k; t < k + elements[number].width; t++)

if (container[i][j][t] != 0){fit = false; break;}

// if it's OK, the coordinate is for this element

if (fit != false) {

cartI = i;

cartJ = j;

cartK = k;

end = true;

}

if (end) break;

tmp++;

}

}

if (end == true) break;

}

if (end == true) break;

}

if (end == true) break;

}

if (container[cartI][cartJ][cartK] == 0) {

//set the coordinate

elements[number].y = contHeight / 2 - (cartI + elements[number].height/ 2);

elements[number].z = contDepth / 2 - (cartJ + elements[number].depth / 2);

elements[number].x = -(contWidth / 2) + cartK + elements[number].width / 2;

// fill the array

for (int i = 0; i < elements[number].height; i++)

for (int j = 0; j < elements[number].depth; j++)

for (int k = 0; k < elements[number].width; k++)

container[cartI + i][cartJ + j][cartK + k] = number + 1;

}

number++;

}

}

public Box[] draw(){

Box[] boxes = new Box[elements.length];

for (int i = 0; i < elements.length; i++) {

if (elements[i].x != 1000000 && elements[i].y != 1000000 && elements[i].z != 1000000){

Box box = new Box(elements[i].width, elements[i].height, elements[i].depth);

switch (elements[i].colour){

case "красный": box.setMaterial(new PhongMaterial(Color.RED)); break;

case "оранжевый": box.setMaterial(new PhongMaterial(Color.ORANGE)); break;

case "желтый": box.setMaterial(new PhongMaterial(Color.YELLOWGREEN)); break;

case "зеленый": box.setMaterial(new PhongMaterial(Color.GREEN)); break;

case "светло-зеленый": box.setMaterial(new PhongMaterial(Color.LIGHTGREEN)); break;

case "голубой": box.setMaterial(new PhongMaterial(Color.BLUE)); break;

case "светло-голубой": box.setMaterial(new PhongMaterial(Color.AQUA)); break;

case "синий": box.setMaterial(new PhongMaterial(Color.DARKBLUE)); break;

case "розовый": box.setMaterial(new PhongMaterial(Color.MAGENTA)); break;

case "светло-розовый": box.setMaterial(new PhongMaterial(Color.PINK)); break;

case "малиновый": box.setMaterial(new PhongMaterial(Color.CRIMSON)); break;

case "фиолетовый": box.setMaterial(new PhongMaterial(Color.BLUEVIOLET)); break;

case "коричневый": box.setMaterial(new PhongMaterial(Color.BROWN)); break;

case "светло-коричневый": box.setMaterial(new PhongMaterial(Color.CHOCOLATE)); break;

case "серый": box.setMaterial(new PhongMaterial(Color.GRAY)); break;

case "черный": box.setMaterial(new PhongMaterial(Color.BLACK)); break;

}

box.setTranslateX(elements[i].x);

box.setTranslateY(elements[i].y);

box.setTranslateZ(elements[i].z);

box.setDrawMode(DrawMode.FILL);

boxes[i] = box;

}

}

return boxes;

}

}