UML предоставляет графические средства для составления “диаграмм”:
диаграммы прецедентов,
диаграммы классов,
диаграмм взаимодействия, а именно: диаграммы последовательностей (sequence diagram) и диаграммы кооперации (collaboration diagram), в частности, системной диаграммы последовательностей. UML доступен в разных системах, в частности, в Microsoft Visio, Rational Rose, Delphi, начиная с издания 8.
6.2. Проект разработки компьютерной поддержки библиотеки
Далее в качестве примера рассматривается разработка компьютерной поддержки библиотеки.
6.2.1. Начальная фаза проектирования
В соответствии с рекомендациями Унифицированного процесса проектирования (UP) [1] во время начальной фазы проектирования в качестве рабочих материалов («артефактов») разрабатываются диаграмма концептуальных классов и диаграмма прецедентов, приведённые ниже.
Диаграмма концептуальных классов отражает условия разработки, состоящие в том, что библиотека не оснащена компьютерной поддержкой, но имеется каталог элементов хранения (ЭХ) и реестр читателей, и то и другое на карточках. Масштаб библиотеки невелик: она обходится одним библиотекарем.
На диаграмме концептуальных классов отражены только операции по выдаче и возврату публикаций, операции, связанные с прецедентами “Регистрация читателя” и “Комплектация библиотеки”, не показаны, чтобы избежать излишней густоты связей. Читатель может указать эти связи на отдельных экземплярах диаграммы концептуальных классов в качестве упражнения.
Наименование ролей и ассоциаций даны в таком объёме, чтобы избегать повторений и переполнения пространства диаграммы.
Далее один из прецедентов представлен в табличной форме. Описание прецедента отражают фактический порядок осуществления заказов на получение публикации в библиотеке. В частности, пользователь имеет самостоятельный доступ к каталогу для поиска публикаций. Каталог не содержит информации о выдаче публикаций, и читатель может её получить только в ходе заказа.
Диаграмма концептуальных классов проекта поддержки библиотеки
Диаграмма прецедентов проекта поддержки библиотеки
Прецедент из проекта поддержки библиотеки
Имя прецедента | Выполнение заказа |
Исполнители | Читатель и библиотекарь |
Описание | Осн. Читатель передает библиотекарю информацию, идентифицирующую себя и публикацию, которую читатель хотел бы получить. Библиотекарь убеждается по реестру, что читатель зарегистрирован в библиотеке и экземпляр требуемой публикации может быть выдан. Библиотекарь передает экземпляр требуемой публикации и фиксирует факт выдачи. A1. Читатель не зарегистрирован в библиотеке. Заказ отклоняется. A2. Читатель зарегистрирован, но заказанная публикация выдана. Заказ отклоняется |
Предусловия | Читатель реализовал прецедент «Справка о наличии» и узнал, что искомая публикация входит в библиотечный фонд. |
Постусловия | Если читатель получил заказанную публикацию, то в карточке читателя отмечается факт выдачи. |
В данном случае, Осн. – основная последовательность действий (основной сценарий).
A1-A2. Альтернативные сценарии.
УПРАЖНЕНИЯ.
1. Описать остальные прецеденты проекта
6.2.2.Первые проектные решения
В рамках следующей фазы проектирования принимается решение о границах проектируемой компьютерной поддержки и её месте в библиотеке. Оно состоит в том, что картотечные каталог и реестр заменяются компьютерной системой, которая обеспечивает ведение двух баз данных – по фонду публикаций и контингенту читателей. Читатель имеет прямой доступ к фонду публикаций для поиска и чтения. Все функции оперативного изменения содержимого баз данных осуществляет библиотекарь. Это решение фиксируется в уточненных описаниях прецедентов (в табличной и графической формах) и диаграммах проектных классов и системных взаимодействий.
Далее представлены первичная версия диаграммы проектных классов, диаграммы системных последовательностей основного сценария прецедента «Выполнение заказа» и соответствующей диаграммы кооперации.
Эти диаграммы представляют интерфейс между пользователем – библиотекарем и проектируемой компьютерной системой и оставляют открытыми многие детали этого интерфейса равно, как и вопросы его реализации внутри системы.
Первичная диаграмма проектных классов
Диаграмма системных последовательностей для прецедента «Выполнение заказа»
Диаграмма кооперации (системная) для сценария «Выполнение заказа»
6.2.3. Ключевые элементы реализации
В ходе реализации принятых решений складывается вполне типовая ситуация, когда информационная система (ИС) должна обеспечивать учёт действий пользователя с некоторым множеством (фондом) однотипных объектов (элементов фонда), например, менеджера с проектами, в рассматриваемом случае - библиотекаря с экземплярами печатных изданий и читателями. Обобщённая концептуальная диаграмма классов в этой ситуации показана на Рис.1.
Рисунок 1. Концептуальная диаграмма классов для типового фрагмента проекта
Единственный атрибут элемента – состояние – обобщает всевозможные состояния моделируемого объекта, например, книга может быть выдана, проект – приостановлен, читатель - зарегистрирован. Ассоциация “действует” обобщает всевозможные действия пользователя, изменяющие состояния объекта, а также “Включение объекта в фонд” и “Изъятие объекта из фонда”.
Диаграмма последовательностей для системных операций представлена на Рис.2, а соответствующая диаграмма кооперации – на Рис.3.
Рисунок 2. Диаграмма последовательностей системных операций для типового фрагмента проекта
Рисунок 3. Диаграмма кооперации системных операций для типового фрагмента проекта
Диаграмма классов проекта строится на основе концептуальной диаграммы классов и диаграмм взаимодействия. При этом определяется набор классов, которые исполняют системные операции, показанные в диаграммах взаимодействия, и служат прототипами классов исходного языка программирования, на котором записывается проект. Первичными кандидатами в классы проекта являются классы концептуальной диаграммы.
Простейшее и вполне удовлетворительное решение этой задачи состоит в назначении всех системных операций классу “Фонд” и реализации их в виде методов соответствующего класса в программе. Выбор в языке программирования способа представления “Элементов”, входящих в “Фонд” определяется следующими требованиями, вытекающими из определения системных операций:
· в “Фонд” может входить любое (в частности, пустое) конечное множество однотипных “Элементов”,
· необходимы элементарные операции для добавления, удаления и выборки “Элемента” по некоторому признаку.
В языке C# этим требованиям удовлетворяют классы List(T) и ArrayList. Функциональность этих классов можно передать классу “Фонд”, реализовав его как их наследника или введя в “Фонд” атрибут типа ArrayList или List(T). Для реализации концептуального класса “Элемент” можно выбрать типы Struct или Class.
На Рис.4 показана диаграмма классов для первого варианта проекта (Варианта А), в котором “Фонд” реализуется как наследник класса List(T).
Рисунок 4. Диаграмма классов для первого варианта фрагмента проекта Соответствующие диаграмма последовательностей и диаграмма кооперации показаны на Рис.5 и 6.
Рисунок 5. Диаграмма последовательностей для первого варианта типового фрагмента проекта
Рисунок 6. Диаграмма кооперации для первого варианта типового фрагмента проекта
В этом варианте проекта установлено, что элементы фона идентифицируются строкой и сам пользователь заботится об уникальности элементов. Хотя на диаграммах показаны только те операции типа List(T), которые необходимы для реализации выбранных системных операций, и не показаны базовые операции, необходимые для реализации пользовательского интерфейса, класс “Фонд” оказался функционально перегружен. Поэтому предложен второй вариант (Вариант Б), в котором введен класс “Список элементов”, и “Фонд” связан с экземпляром этого класса как с элементом своей конструкции. Кроме того, введен класс “Фасад”, который реализует связь с пользователем на базе формы
Соответствующие диаграмма классов и диаграмма последовательностей показаны на Рис.7 и 8.
Рисунок 7. Диаграмма классов для второго варианта проекта
Рисунок 8.Диаграмма последовательностей для второго варианта проекта (операции «Включить» и «Показать»).
Рисунок 9.Диаграмма последовательностей для второго варианта проекта (операции “Ввести” и “Исключить”).
6.2.4. Программная реализация на языке C++
Приведённые выше диаграммы могут быть конкретизированы на языке C++ в среде Microsoft Visual Studio в виде версии CLR следующим образом (проект CppLab02).
Класс Fasade, отвечающий за взаимодействие с оператором, определён в модуле (файле) Fasade. h – наследнике класса Form. Экземпляр класса Fasade как главная форма приложения обеспечивает визуальный интерфейс с оператором, когда приложение запущено. Далее показан вид этой формы.
Пункты главного меню представляют собой операции, которые пользователь активирует, когда работает с фондом. «Включить» создает элемент фонда со свойствами, значения которых пользователь должен перед операцией установить в окнах «Идентификатор» и «Состояние». «Показать» обеспечивает поиск элемента фонда по значению, установленному в окне «Идентификатор», и вывод в свойства State этого элемента в окно «Состояние» на форме. «Ввести» ищет элемент по «Идентификатору» и присваивает свойству State найденного элемента значение из окна «Состояние». «Исключить» находит элемент фонда по значению, установленному в окне «Идентификатор», и удаляет его из фонда. Если поиск в этих операциях не приводит к успеху, то в окне «Состояние» устанавливается значение
-3. Значение окна «Идентификатор» должно быть десятичным числом.
Операции реализуются обработчиками событий Click соответствующих пунктов меню. Их тексты нетрудно найти в листинге
файла Fasade. h, приведённом далее.
#pragma once
#include "Fond. h"
namespace CppLab02 {
using namespace System;
using namespace System::ComponentModel;
using namespace System::Collections;
using namespace System::Collections::Generic;
using namespace System::Windows::Forms;
using namespace System::Data;
using namespace System::Drawing;
/// <summary>
/// Сводка для Fasade
///
/// Внимание! При изменении имени этого класса необходимо также изменить
/// свойство имени файла ресурсов ("Resource File Name") для средства компиляции управляемого ресурса,
/// связанного со всеми файлами с расширением .resx, от которых зависит данный класс. В противном случае,
/// конструкторы не смогут правильно работать с локализованными
/// ресурсами, сопоставленными данной форме.
/// </summary>
public ref class Fasade : public System::Windows::Forms::Form
{
private: CppLab02::_Fond^ vFond;
public: Fasade(void)
{
InitializeComponent();
//
//TODO: добавьте код конструктора
//
vFond = gcnew _Fond();
}
protected:
/// <summary>
/// Освободить все используемые ресурсы.
/// </summary>
~Fasade()
{
if (components)
{
delete components;
}
}
private: System::Windows::Forms::MenuStrip^ menuStrip1;
protected:
private: System::Windows::Forms::ToolStripMenuItem^ включитьToolStripMenuItem;
private: System::Windows::Forms::ToolStripMenuItem^ показатьToolStripMenuItem;
private: System::Windows::Forms::ToolStripMenuItem^ ввестиToolStripMenuItem;
private: System::Windows::Forms::ToolStripMenuItem^ исключитьToolStripMenuItem;
private: System::Windows::Forms::TextBox^ id;
private: System::Windows::Forms::TextBox^ State;
private: System::Windows::Forms::Label^ label1;
private: System::Windows::Forms::Label^ label2;
private:
/// <summary>
/// Требуется переменная конструктора.
/// </summary>
System::ComponentModel::Container ^components;
#pragma region Windows Form Designer generated code
/// <summary>
/// Обязательный метод для поддержки конструктора - не изменяйте
/// содержимое данного метода при помощи редактора кода.
/// </summary>
void InitializeComponent(void)
{
this->menuStrip1 = (gcnew System::Windows::Forms::MenuStrip());
this->включитьToolStripMenuItem = (gcnew System::Windows::Forms::ToolStripMenuItem());
this->показатьToolStripMenuItem = (gcnew System::Windows::Forms::ToolStripMenuItem());
this->ввестиToolStripMenuItem = (gcnew System::Windows::Forms::ToolStripMenuItem());
this->исключитьToolStripMenuItem = (gcnew System::Windows::Forms::ToolStripMenuItem());
this->id = (gcnew System::Windows::Forms::TextBox());
this->State = (gcnew System::Windows::Forms::TextBox());
this->label1 = (gcnew System::Windows::Forms::Label());
this->label2 = (gcnew System::Windows::Forms::Label());
this->menuStrip1->SuspendLayout();
this->SuspendLayout();
//
// menuStrip1
//
this->menuStrip1->Items->AddRange(gcnew cli::array< System::Windows::Forms::ToolStripItem^ >(4) {this->включитьToolStripMenuItem,
this->показатьToolStripMenuItem, this->ввестиToolStripMenuItem, this->исключитьToolStripMenuItem});
this->menuStrip1->Location = System::Drawing::Point(0, 0);
this->menuStrip1->Name = L"menuStrip1";
this->menuStrip1->Size = System::Drawing::Size(292, 24);
this->menuStrip1->TabIndex = 0;
this->menuStrip1->Text = L"menuStrip1";
//
// включитьToolStripMenuItem
//
this->включитьToolStripMenuItem->Name = L"включитьToolStripMenuItem";
this->включитьToolStripMenuItem->Size = System::Drawing::Size(70, 20);
this->включитьToolStripMenuItem->Text = L"Включить";
this->включитьToolStripMenuItem->Click += gcnew System::EventHandler(this, &Fasade::включитьToolStripMenuItem_Click);
//
// показатьToolStripMenuItem
//
this->показатьToolStripMenuItem->Name = L"показатьToolStripMenuItem";
this->показатьToolStripMenuItem->Size = System::Drawing::Size(67, 20);
this->показатьToolStripMenuItem->Text = L"Показать";
this->показатьToolStripMenuItem->Click += gcnew System::EventHandler(this, &Fasade::показатьToolStripMenuItem_Click);
//
// ввестиToolStripMenuItem
//
this->ввестиToolStripMenuItem->Name = L"ввестиToolStripMenuItem";
this->ввестиToolStripMenuItem->Size = System::Drawing::Size(54, 20);
this->ввестиToolStripMenuItem->Text = L"Ввести";
this->ввестиToolStripMenuItem->Click += gcnew System::EventHandler(this, &Fasade::ввестиToolStripMenuItem_Click);
//
// исключитьToolStripMenuItem
//
this->исключитьToolStripMenuItem->Name = L"исключитьToolStripMenuItem";
this->исключитьToolStripMenuItem->Size = System::Drawing::Size(76, 20);
this->исключитьToolStripMenuItem->Text = L"Исключить";
this->исключитьToolStripMenuItem->Click += gcnew System::EventHandler(this, &Fasade::исключитьToolStripMenuItem_Click);
//
// id
//
this->id->Location = System::Drawing::Point(38, 82);
this->id->Name = L"id";
this->id->Size = System::Drawing::Size(100, 20);
this->id->TabIndex = 1;
//
// State
//
this->State->Location = System::Drawing::Point(40, 135);
this->State->Name = L"State";
this->State->Size = System::Drawing::Size(100, 20);
this->State->TabIndex = 2;
//
// label1
//
this->label1->AutoSize = true;
this->label1->Location = System::Drawing::Point(35, 66);
this->label1->Name = L"label1";
this->label1->Size = System::Drawing::Size(87, 13);
this->label1->TabIndex = 3;
this->label1->Text = L"Идентификатор";
//
// label2
//
this->label2->AutoSize = true;
this->label2->Location = System::Drawing::Point(37, 119);
this->label2->Name = L"label2";
this->label2->Size = System::Drawing::Size(61, 13);
this->label2->TabIndex = 4;
this->label2->Text = L"Состояние";
//
// Fasade
//
this->AutoScaleDimensions = System::Drawing::SizeF(6, 13);
this->AutoScaleMode = System::Windows::Forms::AutoScaleMode::Font;
this->ClientSize = System::Drawing::Size(292, 266);
this->Controls->Add(this->label2);
this->Controls->Add(this->label1);
this->Controls->Add(this->State);
this->Controls->Add(this->id);
this->Controls->Add(this->menuStrip1);
this->MainMenuStrip = this->menuStrip1;
this->Name = L"Fasade";
this->Text = L"Работа с фондом";
this->menuStrip1->ResumeLayout(false);
this->menuStrip1->PerformLayout();
this->ResumeLayout(false);
this->PerformLayout();
}
#pragma endregion
private: System::Void включитьToolStripMenuItem_Click(System::Object^ sender, System::EventArgs^ e)
{
vFond->Include(this->State, this->id->Text);
};
private: System::Void показатьToolStripMenuItem_Click(System::Object^ sender, System::EventArgs^ e)
{
vFond->Show(this->State, this->id->Text);
};
private: System::Void ввестиToolStripMenuItem_Click(System::Object^ sender, System::EventArgs^ e)
{
vFond->Write(this->State, this->id->Text);
};
private: System::Void исключитьToolStripMenuItem_Click(System::Object^ sender, System::EventArgs^ e)
{
vFond->Remove(this->State, this->id->Text);
};
};
}
В этих обработчиках вызываются соответствующие методы класса _Fond в соответствии с диаграммой на рис.8 и 9.
Класс _Fond определён в модуле (файле) Fond. h, листинг которого приведён далее.
#pragma once
#include "Fasade. h"
namespace CppLab02 {
using namespace System;
using namespace System::ComponentModel;
using namespace System::Collections::Generic;
using namespace System::Windows::Forms;
using namespace System::Data;
using namespace System::Drawing;
ref class _Element
{
public: String^ id;
int State;
public: _Element(String^ _id, int _State)
{
id = _id;
State = _State;
};
public: ~_Element(void) {};
};
ref class _Fond //: public System::Windows::Forms::Form
{
static int lid;
_Element ^el;
public: List<_Element^>^ _List;
public: _Fond(void)
{
_List = gcnew List<_Element^>();
};
public: ~_Fond() {};
static bool comp(_Element^ ident)
{
if(ident->State == lid)
{
return true;
}
else
{
return false;
};
};
public: _Element^ Find(int vid)
{
lid = vid;
return _List->Find(gcnew Predicate<_Element^>(comp));
};
public: void Include(TextBox^ sender, String^ _id)
{
_List->Add(gcnew _Element(sender->Text, Convert::ToInt32(_id)));
};
public: void Show(TextBox^ sender, String^ _id)
{
el = Find(Convert::ToInt32(_id));
if (el!=nullptr){sender->Text = el->id;}
else{sender->Text = "-3";};
};
public: void Remove(TextBox^ sender, String^ _id)
{
el = Find(Convert::ToInt32(_id));
if(el!=nullptr){if(!_List->Remove(el))
{sender - >Text = "-3";};}
else{sender->Text = "-3";};
};
public: void Write(TextBox^ sender, String^ _id)
{
el = Find(Convert::ToInt32(_id));
if (el!= nullptr){el->id = sender->Text;}
else{sender->Text = "-3";};
};
};
}
В этом же модуле определён класс _Element, для хранения экземпляров которого предназначены экземпляры класса _Fond.
Заслуживает внимания организация поиска в фонде.
В классе _Fond хранимые элементы (экземпляры класса _Element) представлены полем _List. Тип этого поля – параметризованый класс List(T), определённый в среде проектирования. Экземпляры этого класса – списки элементов типа T, в нашем случае – типа _Element.
Метод Find класса _Fond, предназначенный для поиска в списке элементов, использует метод Find класса List(T).Этот метод применяет к каждому элементу списка предикат, полученный им в качестве входного параметра. Этот предикат порождается на основе метода comp класса _Fond. Выполнение предиката фактически состоит в выполнении этого метода comp применительно к элементу, поданному ему на вход, в среде метода Find. Поэтому он использует для сравнения локальную переменную lid, содержащую поисковый признак. Если comp возвращает true, то элемент возращается методом Find, как результат поиска. В противном случае возвращается «нулевой» указатель.
УПРАЖНЕНИЯ
1. Реализовать ключевые элементы реализации, приведённые в п.6.2.4, на языке C# Microsoft Visual Studio 2008 для среды CLR.
2. Реализовать ключевые элементы реализации, приведённые в п.6.2.4, на языке C++ в Microsoft Visual Studio 2008 для среды Win32.
ПРИЛОЖЕНИЕ 1
Синтаксис и семантика класса в языках Object Pascal, C#, C++, Java
Определение типа class.
Type <имя класса> = class [(<имя класса-предка>)]
<компонент класса>
…
<компонент класса>
end;
Класс – тип данных, экземпляр которых называется объектом. Объект – порция данных, имеющая определенную классом структуру и типы значений. Переменная, типом которой является некоторый класс, содержит указатель на эту область.
Иерархия классов.
Компоненты класса
<компонент класса> = :: <поле> | <метод>| <свойство>
<поле> =:: [<атрибут видимости >] <имя поля> : <тип>;
.
Связь между типами class и record.
Поля должны идти до всех остальных компонентов. Доступ к полю
<метод> = :: [<атрибут видимости >]<метод-функция>; [<директивы>] |
[<атрибут видимости >]<метод-процедура>;[<директивы>] |
[<атрибут видимости >]<конструктор> ;[<директивы>] |
[<атрибут видимости >]<деструктор>; [<директивы>]
<директивы> =:: <директива >;<директива>; … <директива>;
<директива> =:: reintroduce | overload | virtual | dynamic | override | register | pascal | cdecl | stdcall | safecall | abstract | message | platform | deprecated | library
<cвойство> = :: [<>]property <имя>:<тип>{[read <имя функции>]
[write<имя процедуры>]}
[stored <Булево значение>]
[default <значение>] | nodefault];
stored и default управляют сохранением публикуемого свойства в модуль .dfm. По умолчанию store true. Default имеет силу только для порядковых значений и значений типа set в диапазоне от 0 до 31. Для строки, вещественного типа и указателей умолчание неявное.
<cвойство> = :: [<>]property <имя>[<индекс>:<тип>]:<тип>{[read <имя функции>]
[write<имя процедуры>]}
[stored <Булево значение>]
[default | nodefault];
<атрибут видимости > =:: private | protected | public | published | automated
Далее сравнительный обзор языков C++, Java и C# приводится c опорой на Object Pascal.
2.7.1. Что общего у этих четырёх языков?
Хотя это разные языки – существенные различия наблюдаются на уровнях _ лексики, синтаксиса и семантики – они, несомненно, могут быть отнесены к одному типу, который характеризуется общей “архитектоникой” – составом и иерархическим соподчинением языковых компонентов.
Лексику во всех этих языках образуют: зарезервированные слова и специальные знаки, литералы и идентификаторы (имена). Синтаксис оперирует с термами (литералами и идентификаторами), выражениями, простыми и составными предложениями (statement).
Главное содержание (смысл) программы – это определение некоторого пространства, в котором при конкретном выполнении программы размещаются значения обрабатываемых при этом выполнении данных, а также определение преобразования этих значений, и, в некоторых случаях, самого пространства. Это преобразование обычно разделяется на относительно самостоятельные компоненты, которые сопоставляются с предложениями особого типа, так называемыми, операторами или “инструкциями” и трактуются как их содержание (смысл). Последовательности таких предложений-операторов явно задают (с точностью до количества прохождений через них) последовательность “передачи управления” между ними, иными словами, последовательность шагов преобразований, выполняемых программой. Для всех четырёх рассматриваемых языков последовательность передачи управления задаётся явно: последовательностью расположения операторов в программе и специальными операторами перехода, что позволяет отнести все четыре рассматриваемых языка к языкам “операторного” типа.
Кроме предложений операторного типа в рассматриваемых языках имеются предложения типа объявления/определения, а также предложения и конструкции специального типа, в частности: блоки, конструкции для организации обработки особых случаев (“исключений”), организации областей видимости имён.
Во всех именах имеется глобальное пространство имён, которое может охватывать несколько модулей-файлов, но в разных языках оно организовано по-разному.
2.7.2. Что общего у языков C++, Java и C#, что отличает их от Object Pascal?
На уровне лексики: case-sensitivity (лексемы, различающиеся регистром букв – разные лексемы).
Тип “строка” представлен только 0-терминированной строкой и специальными классами.
Имеется тип void, используемый, в частности, для объявления безтипового указателя.
Операции:
&& вместо AND
|| вместо OR
! вместо NOT
== вместо =
!= вместо <>
& для побитового И
| для побитового ИЛИ
^ для побитового НЕТ
Есть операции сдвига битов << и >>
Операторы (инструкции):
Оператор присваивания = вместо :=, оператор присваивания возвращает значение (присвоенное).
Границы блока {}, а не begin и end.
Конструкция условного перехода (ветвления):
if (условие) простой оператор или блок [else простой оператор или блок]
for (инициатор, условие, шаг) простой оператор или блок
где инициатор и шаг – последовательность операторов.
while (условие) простой оператор или блок
do простой оператор или блок while (условие)
switch (выражение){
сase значение: последовательность операторов
case значение: последовательность операторов
…
case значение: последовательность операторов
[ default простой оператор или блок] }
Аналоги этим конструкциям в языке Pascal очевидны. Однако switch существенно отличается от case языка Pascal тем, что если выражение имеет одно из значений, предусмотренных в case, то вслед за последовательностью операторов этого выбранного case выполняются последовательности всех нижележащих case.
Кроме того, имеется конструкция “запятая”, отсутствующая в языке Pascal:
(условие)?оператор присваивания, … ,оператор присваивания
: оператор присваивания, … ,оператор присваивания;
Синтаксис объявления:
спецификатор тип имя [= выражение]
Порядок имени и типа составляет нарочитое формальное отличие от языка Pascal. Принципиальное отличие состоит в том, что в языке Pascal объявления сосредоточены в определённых позициях текста программы, отмеченных специальными зарезервированными словами: type, var, const в разделах implementation модулей, между заголовком функции или процедуры и begin и т. п.
Это, во-первых, придаёт тексту на языке Pascal “формулярный” вид и, во-вторых скрывает действие, связанное с объявлением: выделение области памяти, соответствующее форматирование. Эти действия оторваны от операторной части программы и происходят в обязательном порядке как бы предосмотра до выполнения операторов.
В языках C++, Java и C# объявление простого типа располагается среди операторов и действенно, если только через него “пройдёт управление”.
Константа – частный случай переменной: переменная со спецификатором const.
Важную роль играет спецификатор static. Кроме классов, он может быть использован в функциях.
Новый экземпляр типа может быть создан динамически с помощью оператора new, в частном случае:
переменная = new
Однако в различных языках для такого создания требуются дополнительные спецификации.
Определение функции:
спецификатор тип имя([список формальных параметров])тело функции
Тело функции представляет собой блок.
Определение без тела, то есть заголовок функции образует её объявление. Объявления обеспечивают использование функции в нескольких различных частях (модулях) программы при наличии одного определения.
Тип в заголовке функции – это тип возвращаемого ею значения. Это значение представлено в теле функции встроенной переменной return. Если значение не возвращается, то есть функция является процедурой, как в языке Pascal, то должен быть указан тип void.
Круглые скобки после имени служат формальным признаком функции при её объявлении (определении) и вызове. Список параметров может быть пустым.
функция main вызывается при запуске программы. Аргументы этой функции передаются операционной системой из командной строки.
Все рассматриваемые языки содержат типы class и interface, однако синтаксис объявления варьирует от одного языка к другому.
Конструктор получает имя класса.
Обращение к вызывающему объекту (self в языке Pascal) обеспечивается встроенным словом this.
Пространство имён структурировано, могут быть определены подпространства.
2.7.3. Особенности языка C++.
Среди типов нет типа struct.
Определение типа с помощью оператора typedef.
Кроме указателей есть тип “ссылка”. В функциях он используется для передачи значения по ссылке.
Оператор new вырабатывает указатель, например;
int ^n = new int
или
int ^n = new int(0) с инициализатором.
Имеется возможность заранее выделять место и в нём размещать объект.
Для уничтожения объекта в случае его динамического создания предназначен оператор delete.
Автоматические объекты могут создаваться со спецификатором register.
В объявлении функции могут отсутствовать имена формальных параметров (только типы).
При объявлении и определении функций можно задавать значения по умолчанию. Они подставляются вместо отсутствующих последних фактических параметров.
В объявлении функции может быть задан список формальных параметров с переменное количество элементов:
(…) или (параметр, …) или (параметр …).
В целом, можно заметить, что в C++ процедурно-ориентированное программирование испытало далеко идущее развитие. В частности, имеются шаблоны-функции (функции, в которых тип является свободным параметром, который может быть установлен при их использовании) и обобщённые функции (generic).
Определение класса:
[спецификатор] class имя класса [: спецификатор-видимости имя-класса, …, спецификатор-видимости имя-класса ][{тело класса}] [переменные];
Объявление – это определение без тела. Объявление позволяет пользоваться именем в ограниченных целях – для определения указателей.
Для C++ характерно множественное наследование.
Возможно вложение классов.
Нестатические поля нельзя инициировать в теле класса.
В классе отсутствуют свойства как член класса.
Методы могут быть встроенными и невстроенными. Невстроенные связываются с классом через ::, то есть
имя-класса :: имя-функции
Экземпляр класса может быть создан динамически оператором new, а также обычным указанием имени класса при имени переменной.(инициализация осуществляется конструктором по умолчанию).
Деструктор именуется ~имя-класса
Обращение к члену класса осуществляется через “точку”, если база – объект (переменная, типа класс), и через -> (“стрелку”), если база – указатель на объект.
Виртуализация метода обеспечивается спецификатором virtual.
Обращение к членам классов вверх по иерархии наследования обеспечивается оператором using.
Имеются шаблоны классов (тип – свободный параметр).
Глобальное поле видимости обеспечивается оператором #include, проставляемыми в начале модуля. Предусмотрены специальный тип файлов – заголовочный (расширение h).
Пространство имён задаётся или продолжается оператором
namespace имя-пространства { пространство }
Объект в пространстве имён квалифицируется именем пространства через ::.
Глобальное пространство не имеет имени. Можно определить безымянное локальное пространство имён.
Using задаёт имя пространства по умолчанию до конца текущего пространства имён.
2.7.4. Особенности языка Java.
Компиляция осуществляется в специальный промежуточный байт-код, исполняемый аппаратурно-независимой Java-машиной, которая создаёт для программы “контекст времени выполнения”.
UNICODE.
Нет оператора goto.
Конкатенация выражается знаком +.
Строка выражается объектом класса string. Этот объект доступен только для чтения. При изменении старый экземпляр уничтожается и создаётся новый.
Указателей как отдельного типа нет (?).
В функциях и методах передача параметров только по значению. Указатель дублируется. Возврат составных значений – только через объект.
Определение класса
спецификатор class имя [extends имя-предка]{тело}[implements имя-интерфейса]
В классе отсутствуют свойства как член класса.
Определения методов встроенные (?).
В определении класса предусмотрены блоки статической инициализации
static { };
Нет деструкторов.
Создание объекта – посредством оператора new.
Обращение к члену класса – через “точку” от имени переменной, содержащей объект.
Обращение к членам классов вверх по иерархии наследования обеспечивается оператором super.
Классы могут быть (по спецификатору) abstract, final
Нет глобальных статических переменных.
Приложение запускается с указанием имени класса, в котором вызывается функция с именем main.
Глобальное поле видимости обеспечивается оператором package, проставляемыми в начале модуля.
package имя-пакета
import имя-пакета.*
2.7.5. Особенности языка C#.
Компиляция осуществляется в специальный промежуточный байт-код, исполняемый аппаратурно-независимой средой в. Net, которая создаёт для программы “контекст времени выполнения”. Исполняемый файл exe вызывает “контекст времени исполнения”.
Есть типы decimal и struct.
Нет указателей.
Определение класса
[спецификатор] class имя класса [: спецификатор-видимости имя-класса][{тело класса}];
Наследование от класса однозначное. Множественное наследование может быть наследование от интерфейсов.
Поля могут иметь спецификатор const.
Методы встроенные. В методе могут быть передачи параметров по ссылке с инициализацией и без инициализации параметра (ref и out).
Есть свойства
спецификация тип имя-свойства {
get {return = }
set { }
}
Классы могут быть (по спецификатору) abstract, final, partial
Введёна специальная разновидность членов класса – “событие”, которым можно присваивать в качестве значения цепочку указателей на обработчики. Присвоение в форме
имя события+=new имя-делегата(объект. имя обработчика)
События определяются
public event имя-делегата имя-события
где определяется как тип
public delegate void имя-делегата (сигнатура)
Могут определяться деструкторы
~ имя-класса ( )
но они явно не вызываются.
Пространство имён задаётся или продолжается оператором
namespace имя-пространства { пространство }
Using задаёт имя пространства по умолчанию до конца текущего пространства имён.
Объект в пространстве имён квалифицируется именем пространства через “толчку”.
Приложение запускается с указанием имени класса, в котором вызывается функция с именем main.
ПРИЛОЖЕНИЕ 2
Основы языка UML
|
Из за большого объема этот материал размещен на нескольких страницах:
1 2 3 |
