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

Размещено на http://www.allbest.ru/

МИНИСТЕРСТВО ОБРАЗОВАНИЯ И НАУКИ РЕСПУБЛИКИ ТАДЖИКИСТАН

ТАДЖИКСКИЙ ТЕХНИЧЕСКИЙ УНИВЕРСИТЕТ

имени академика М.С. Осими

МЕТОДИЧЕСКИЕ УКАЗАНИЯ

к выполнению лабораторных работ по курсу

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

для студентов специальности 530102 - Автоматизированные системы обработки информации и управления

ДУШАНБЕ - 2018



МИНИСТЕРСТВО ОБРАЗОВАНИЯ И НАУКИ РЕСПУБЛИКИ ТАДЖИКИСТАН

ТАДЖИКСКИЙ ТЕХНИЧЕСКИЙ УНИВЕРСИТЕТ

имени академика М.С. Осими

ФАКУЛЬТЕТ «ИНФОРМАЦИОННО-КОММУНИКАЦИОННЫХ ТЕХНОЛОГИЙ»

МЕТОДИЧЕСКИЕ УКАЗАНИЯ

к выполнению лабораторных работ по курсу «Объектно-ориентированное программирование»

для студентов специальности 530102 - Автоматизированные системы обработки информации и управления

ДУШАНБЕ 2018



УДК 621.396.6(075)

«УТВЕРЖДАЮ»

Председатель МС ТТУ

им. акад. М.С.Осими

д.т.н. доцент Саидзода Р.Х.

________________________

«____» «______________» 2018 г

Авторы: Юнусов Н.И. - к.т.н., доцент, Бадалова М.А., Бандишоева Р.М. - старшие преподаватели кафедры «Автоматизированные системы обработки информации и управления», Норкулов Х.О. - старший преподаватель кафедры «Информатика».

Методические указания к выполнению лабораторных работ по курсу «Объектно-ориентированное программирование» для студентов специальности: 530102 - Автоматизированные системы обработки информации и управления - Душанбе: ТТУ имени академика М.С. Осими, 2018, 107 стр.

Рецензенты:

Абдувасиева З.С. - к.т.н., доцент кафедры «Информатика и информационная технология» РТСУ.

Муминов М.Х. - начальник отдела «Информационная технология» ТТУ им.акад. М.С.Осими.

Методические указания посвящены проведению лабораторных работ по курсу «Объектно-ориентированное программирование». Пособие состоит из 4-х лабораторных работ, посвящённых разработке программных продуктов на основе современной методологии объектно-ориентированного программирования (ООП). В методическом указании нашли отражения вопросы, содержащие краткие теоретические сведения об абстракции, инкапсуляции, наследовании и полиморфизме. В каждой лабораторной работе приводятся краткие теоретические сведения, порядок выполнения отдельных её этапов, задание к самостоятельной работе. В конце пособия приведена структура и форма представления отчетности, основные требования к оформлению лабораторных работ. Принципы ООП рассматриваются для программирования в среде VisualBasic, Delphi, С++ и C#. Методическими указаниями могут воспользоваться все студенты, изучающие программирование на языках высокого уровня.

Утвержден Методическим советом ТТУ имени академика М.С. Осими __ _______ 2018 г. протокол №___

© Таджикский технический университет им. академика М.С.Осими, 2018г.



Лабораторная работа №1. Создание класса диалогового окна на VB

Цель работы. Приобретение навыков объектно-ориентированного программирования на примере создания класса диалогового окна в среде Visual Basic Знакомство с диалоговыми окнами, встроенными в Visual Basic, a также созданием собственных диалоговых окон, которые могут быть включены в другие проекты.

Общие сведения

Стандартные диалоговые окна

В проектах Visual Basic часто встречаются две разновидности диалоговых окон: окна сообщений и окна ввода. Они встроены в Visual Basic, и если их возможностей окажется достаточно, вам не придется проектировать нестандартные диалоговые окна. Окно сообщения(МsgВох()) выводит простейшие сообщения для пользователя, а окно ввода (InputBox()), напротив, служит для ввода информации.

Окно сообщения

Оператор для создания окна сообщения выглядит так (в сокращенном варианте):

MsgBox (сообщение, атрибуты, заголовок)

где сообщение -- текст, отображаемый в диалоговом окне; параметр атрибуты определяет особенности окна -- а именно различные кнопки и значки, отображаемые в нем; заголовок -- строка в заголовке окна. В приложении А перечислены значения этого параметра и константы, используемые для определения окна сообщения.

Значения констант можно складывать, чтобы достичь желаемого результата. Например, чтобы в окне сообщения присутствовали кнопки OK и Cancel, a также значок информационного сообщения, можно воспользоваться любым из приведенных ниже вариантов:



DlgDef = vbOKCancel + vblnformation

DlgDef = 1 + 64

Затем значение переменной DlgDef используется при вызове MsgBox().

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

Dim гс As Integer 'Объявление переменной rc

rc = MsgBox(сообщение, атрибуты, заголовок) 'rc будет 'содержать код возврата

Обратите внимание на скобки, необходимые при вызове функции. Различные коды возврата при использовании функции MsgBox() перечислены в приложении А.

Окно ввода

Окно ввода, как и окно сообщения, может отображаться оператором или функцией. Сокращенный синтаксис функции выглядит так:

Dim гс As String

гс = InputВох(сообщение, заголовок, умолчание)

На этот раз параметр атрибуты отсутствует, однако появляется дополнительный параметр умолчание. В нем можно задать строку, которая будет по умолчанию находиться в текстовом поле. Когда пользователь нажимает кнопку OK, содержимое этого поля присваивается переменной (в нашем примере rс). Если пользователь нажал кнопку Cancel, возвращается строка нулевой длины(пустая строка). Следующий пример показывает, как пользоваться функцией InputBox.

1. Создайте новый проект командой File > New Project.

2. Выберите в Windows Forms Application

3. Добавьте кнопку на форму Form1.

4. В окне свойств задайте свойству Name кнопки значение cmdTryMe.

5. Задайте свойству Text кнопки значение &Нажми меня.

6. Дважды щелкните на кнопке cmdTryMe, чтобы открыть окно программы.

7. Добавьте следующий фрагмент в процедуру события Click кнопки cmdTryMe:

Private Sub cmdTryMe_Click()

Dim rс As String

rc = InputВох("Введите имя:")

MsgBox "Привет, " & rс & "!" ' & знак конкатенации, т.е. ' слияния текстов

End Sub

8. Запустите программу командой Run > Start.

9. Нажмите кнопку, чтобы вызвать диалоговое окно InputBox.

10. Введите в текстовом поле свое имя и нажмите кнопку ОК.

Если все сделано правильно, в окне ввода вам будет предложено ввести имя, после чего Visual Basic выдает окно сообщения со строкой типа «Привет, Тимур!» (разумеется, в вашем случае будет выведено имя, заданное в окне ввода).



Ход выполнения работы

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

1. Откройте окно программы для предыдущего примера.

2. Добавьте следующий фрагмент:

Private Sub LoginBox()

Dim rс As String

rс = InputBox("Bведитe имя:")

If rс = "Директор" Then

MsgBox "Здравствуйте, Директор!"

Else

MsgBox "Привет, " & rс & "!"

End If

End Sub

3. Измените код процедуры события Click кнопки cmdTryMe:

Private.Sub cmdTryMe_Click()

LoginBox

End Sub

4. Запустите приложение.

5. Введите в текстовом поле строку Директор и нажмите кнопку ОК.

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

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

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

Создание класса диалогового окна

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

1. Создайте новый проект командой File > New Project.

2. Выберите тип проекта ActiveX DLL и нажмите кнопку ОК.

3. Создайте в проекте модуль класса и задайте свойству Name значение modDialogs.

4. Откройте окно программы модуля modDialogs и добавьте следующую процедуру:

Sub Main()

Данная процедура может не содержать программного кода,

однако она необходима для правильной работы DLL.

End Sub

5. Дважды щелкните на классе Class1 в окне проекта, чтобы сделать его активным.

6. Задайте следующие свойства класса.

Name:

Instancing:

clsDialogs

5 - MultiUse

Первое диалоговое окно, которое мы создадим, предназначено для ввода логических величин, например, ответов на вопросы типа «Вы уверены?» Такие окна нужны перед выполнением каких-либо критических действий (например, закрытия приложения с несохраненными данными или форматированием диска). Все, что от вас требуется, -- выбрать заголовок и текст сообщения и передать их функции YNBox. После этого остается лишь проверить, равно ли возвращаемое значение vbYes (то есть 6).

Откройте окно программы для класса clsDialogs и добавьте в него следующую функцию:

Public Function YNBox(title As String, msg As String) As Integer

Dim rc As Integer

Dim DlgDef As Long

DlgDef = vbYesNo + vbQuestion

rc = MsgBox(msg, DlgDef, title) `возвращаемое значение rc `равно 6, если

YNBox = rc `нажата кнопка Yes, а если `нажата No то rc будет равно 7

End Function



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

Public Sub ErrMsg(title As String, msg As String)

Dim rc As Integer

Dim DlgDef As Long

DlgDef = vbOkCancel + vbCritical

rc = MsgBox(msg, DlgDef, title)

End Sub

Этой процедуре достаточно передать заголовок (title) и текст сообщения (msg), а она сделает все остальное.

Осталось написать последнюю функцию, создающую диалоговое окно для регистрации пользователя. Единственная цель диалогового окна - немного облегчит ввод имени. Тем не менее позднее вы можете создать полноценное диалоговое окно с текстовыми полями, маскирующими вводимые символы, ограничивающими длину пароля и т. д. Созданное окно можно будет вызывать вместо функции InputBox()

1. Добавьте следующий фрагмент:

Public Function LoginBox (title As String, msg As String, _

default As String) As String

Dim rc As String

rc = InputBox(msg, title)

LoginBox = rc

End Function



2. Сохраните проект под именем dialogs.vbp.

3 Откройте диалоговое окно Project Properties и введите строку Dialogs в поле Project Name. В поле Project Description введите строку Класс для работы с диалоговыми окнами.

4. Перейдите на вкладку Make и введите в поле Application Title строку Dialogs.

5. Созданный класс необходимо откомпилировать, чтобы им можно было пользоваться в приложениях. Выполните команду File > Make Dialogs.Dll и нажмите кнопку ОК.

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

Использование класса диалоговых окон

В предыдущем примере мы разработали простейший класс для работы с диалоговыми окнами. Ознакомившись со следующим примером вы поймете, как библиотеки ActiveX DLL используются в приложениях. После этого вы сможете продолжить работу над классом и приспособить его к своим целям. Давайте создадим небольшое приложение для проверки класса:

1. Создайте новый проект командой File > New Project. Выберите значок Windows Forms Application.

2. Задайте следующие свойства формы Form1.

Name:

Caption:

FrmDialogs

Создание диалоговых окон

3. Поместите на фоpмy.frmDialogs две надписи (Label). Задайте их свойства.

Name:

Caption:

IblTitle

IblMsg

Заголовок:

Сообщение:

4. Добавьте два текстовых поля (TextBox)и задайте их свойства.

Name:

Text:

txtTitle

Пустое поле

txtMsg

Пустое поле

5. Добавьте на форму три кнопки (Button)и задайте их свойства.

Name:

Caption: cmdYN

&Да/нет

cmdErr

&0шибка cmdLogin

&Регистрация

Примерный вид формы показан на рис. 1.

Рис. 1. Форма для работы с классом диалоговых окон



6. Откройте окно программы и введите следующий фрагмент в секции General/Declarations:

Option Explicit

Dim dlg As clsDialogs

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

Private Sub Form_Load()

Set dlg = New clsDialogs

End Sub

10. Если ваша программа создает экземпляр объекта, она должна уничтожать его, когда он становится ненужным. Поскольку класс используется на протяжении всего жизненного цикла приложения, уничтожать его следует при выходе из приложения. Добавьте следующий фрагмент в процедуру Form_Unload():

Private Sub Form_Unload(Cancel As Integer)

Set dlg = Nothing

End Sub

11. Добавьте следующий фрагмент, предназначенный для тестирования логических окон (YNBox):

Private Sub cmdYN_Click()

Dim rc As Integer

rc = dlg.YNBox(txtTitle.Text, txtMsg.text)

If rc = vbYes Then

MsgBox "Нажата кнопка Yes"

Else

MsgBox "Нажата кнопка No"

End If

End Sub

12. Добавьте фрагмент, предназначенный для тестирования окон ошибок (ErrMsg):

Private Sub cmdError_Click()

dlg.ErrMsg txtTitle.Text, txtMsg.text

End Sub

13. Добавьте фрагмент, предназначенный для тестирования окон регистрации (LoginBox):

Private Sub cmdLogin_Click()

Dim UserID As String

UserID = dlg.LoginBox(txtTitle.Text, txtMsg.Text, "")

If UserID <> "" Then

MsgBox UserID & " успешно зарегистрирован!"

End If End Sub

14. Сохраните и запустите проект.

Если все было сделано правильно, вы сможете ввести текст в полях Заголовок и Сообщение. Чтобы проверить, как работают логические окна:

1. Введите в поле Заголовок строку Выход?

2. Введите в поле Сообщение строку Вы уверены?

3. Нажмите кнопку Да/Нет.

На экране появляется диалоговое окно, изображенное на рис. 3.



Рис. 3. Диалоговое окно YNBox

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

1. Введите в поле Заголовок строку Системная ошибка.

2. Введите в поле Сообщение строку Диск не удается отформатировать!

3. Нажмите кнопку Ошибка.

Появляется диалоговое окно, изображенное на рис. 4.



Рис. 4. Диалоговое окно ErrMsg

Хотя диалоговое окно LoginBox станет полезным лишь после основательной доработки, простейший тест из этого примера показывает, как работать с окном ввода. Чтобы проверить, как работают окна LoginBox:

1. Введите в поле Заголовок строку Регистрация.

2. Введите в поле Сообщение строку Введите имя пользователя:

3. Нажмите кнопку Регистрация.

Появляется диалоговое окно, изображенное на рис. 5.



Рис. 5. Диалоговое окно для регистрации пользователей

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

В этом примере мы не только научились пользоваться диалоговыми окнами, но и вкратце познакомились с тем, как в Visual Basic создаются объекты.

Задания для самостоятельного выполнения

1. Используя стандартные окна сообщений Visual Basic создайте класс объектов для вывода информации.

2. Используя окно ввода создайте класс объектов для простейшего сбора информации.

3. Создайте нестандартные диалоговые окна используя произвольные экземпляры класса.

4. Используя класс диалоговых окон создайте небольшое приложение.



Лабораторная работа №2. Создание класса и методов в среде программирования Delphi

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

Общие сведения

Особенность типа "класс" в Delphi, как и в Visual Basic состоит в том, что он содержит наряду с полями методы и свойства. Это значит, что класс описывает группу данных и одну (или более) процедуру или функцию, которая имеет доступ к этим данным. Процедуры и функции называются методами. Тип "класс" - это структура данных, состоящая из некоторого количества элементов: полей, методов, свойств. Поля содержат данные определенного типа. Методы - это функции и процедуры, выполняющие определенные действия. Свойства - это поля данных, которые влияют на поведение объекта. Они служат для описания объекта и отличаются от обычных полей тем, что присвоение им значений связано с вызовом методов.

Каждый новый класс в Delphi должен быть объявлен. Для этого используется зарезервированное слово class. Объявление определяет функциональные возможности класса. В Delphi-версии языка Object Pascal новый класс объявляется следующим образом: TNew = class(TOld);

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

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

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

В Delphi используется четыре атрибута видимости, называемых также директивами: published, public, protected и private.

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

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

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

Директива published похожа на другие атрибуты видимости (private, public, protected) тем, что она может встречаться только в объявлении типа класса. Опубликованное (published) поле или метод может использоваться не только во время выполнения программы, но и во время её разработки. Все компоненты в палитре компонентов Delphi располагают published-интерфейсом, который используется в первую очередь инспектором объектов. Правила видимости для директивы published - те же, что и для public. Различие между общими (public) и опубликованными (published) элементами состоит в том, что во время выполнения программы можно получить информацию о типах (RTTI - Run-tyme type information) опубликованных элементов класса. С помощью этой информации в приложении можно динамически определить и использовать поля и свойства любого, в том числе и неизвестного, типа класса.

Ход выполнения работы

Создать класс TVector и написать для него методы (процедуры и функции), реализующие стандартные операции для векторов.

В Delphi есть зарезервированное слово class, которое позволяет описывать класс. При создании в Delphi нового проекта в модуле unit1 появляется объявление класса основной формы. Ниже приведен пример стандартного объявления класса:

type

Tform1 = class(Tform)

private

{ Private declarations }

public

{ Public declarations }

end;

По негласному соглашению программисты Delphi начинают имя типа класса с большой буквы T, а имя поля (что будет использовано далее) - с большой буквы F. После служебного слова class в круглых скобках указывается базовый класс, от которого порождаются данные.

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

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

Type

Tvector = class private

Fvalues: array of double;

//Далее идут 4 accessing метода, которые, в соответствии

// с принципом инкапсуляции, должны быть объявлены в //разделе private

function GetLength: integer;

procedure SetLength(const Value: integer);

function GetValues(Index: integer):double;

procedure SetValues(Index: integer; const Value: double);

public

//Представление вектора как строку

function AsString: string;

//Длина вектора

property Length: integer read GetLength write SetLength;

//Получение произведения вектора как скаляр

Product( Factor: double); overload;

//Получение произведения двух векторов

procedure Product( const SecondVector: Tvector); overload;

end;



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

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

В разделе private объявлены методы доступа, начинающиеся со слов Get и Set. Способ написания имен тоже принят программистским сообществом.

В разделе public объявлены имена некоторых необходимых методов в виде процедур и функций, а также свойство (служебное слово property) класса Length (число элементов в массиве) и действия, связанные с чтением и записью значения этого атрибута. Можно было бы назвать это свойство другим именем (например, size), но мы намеренно взяли имя Length, для того чтобы показать, как выходить из положения, когда используемое имя совпадает с системным.

Обращаем также внимание на то, что в разделе public объявлены два метода с одинаковым именем Product, и каждое из них заканчивается служебным словом overload (перегрузка). Эта новая возможность позаимствована, начиная с Delphi 7, из C++. Она разрешает иметь несколько функций и процедур с одинаковым именем. Однако у них должны быть разные наборы параметров или их типы. Тип возвращаемого результата не может служить различием. В нашем случае перегружается метод Product. В одном случае вычисляется произведение элементов вектора на некоторое значение, а в другом - поэлементное произведение двух векторов.

Приведенное объявление помещается в разделе interface модуля Delphi, а текст объявленных методов (процедур и функций) - в разделе implementation. Для рассматриваемого примера код соответствующего модуля будет выглядеть так:



unit Vectors;

interface uses

SysUtils, Classes;

Type

//Вектор

Tvector = class

private

Fvalues: array of double;

function GetLength: integer;

procedure SetLength(const Value: integer);

function GetValues(Index: integer):double;

procedure SetValues(Index: integer; const Value: double);

procedure CheckIndex(Index: integer);

public

constructor Create;

//Значения вектора принимают символьный тип

function AsString: string;

//описание свойств вектора

property Values[Index: integer]: double

read GetValues Write SetValues; default;

//Длина вектора

property Length: integer read GetLength write SetLength;

//Получение произведения вектора на скаляр Product( Factor: double); overload;

//Вычисление поэлементного произведения двух векторов

procedure Product( const SecondVector: Tvector); overload;

end;

implementation

{Tvector}

constructor Tvector.Create; begin System.SetLength(Fvalues, 1); end;

function Tvector.AsString: string;

var i: integer;

begin

Result:= `(`;

for i:=0 to Length-1 do begin

if i>0 then Result:= Result+', `; Result:=Result+Format(`%.3n',[Values[i]]);

end; Result:=Result+')'; end;

function Tvector.GetLength: integer; begin Result:=System.Length(Fvalues); end;

function Tvector.GetValues(Index: integer): double;

begin CheckIndex(Index); Result:=Fvalues[Index]; end;

procedure Tvector.SetLength(const Value: integer);

begin

if Value<1 then

raise Exception.Create('Invalid vector length'); System.SetLength(Fvalues, Value);

end;

procedure Tvector.SetValues(Index: integer; const Value: double);

begin CheckIndex(Index); Fvalues[Index]:=Value; end;

procedure Tvector.CheckIndex(Index: integer);

begin

if (Index>=0) and (Index>=Length) then

raise Exception.Create(`Index out of the bounds');

end.

Procedure Tvector.Product(const SecondVector: Tvector);

var i: integer;

Begin

For i:=0 to SecondVector.Length-1 do

Fvalues[I]:= Self[i] * SecondVector[i];

end;

end.

Задания к работе:

1. Изучить назначение метода construсtor.

2. Написать методы:

- для сложения векторов (Tvector.Add(const SecondVector: Tvector));

- умножения вектора на значение (Tvector.Product(Factor: double));

- получения скалярного произведения векторов.

3. Создать форму для отображения результатов работы проекта.

Ниже приведен возможный вариант реализации п.3

unit UnitMain;

interface uses

Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms, Dialogs, StdCtrls;

type

Tform1 = class(Tform); ButtonInput: Tbutton; Memo1: Tmemo; ButtonExit: Tbutton;

procedure ButtonInputClick(Sender: Tobject); procedure ButtonExitClick(Sender: Tobject); private

{ Private declarations }

public

{ Public declarations }

end;

var

Form1: Tform1;

implementation uses Vectors;

{$R *.dfm}

procedure Tform1.ButtonInputClick(Sender: Tobject);

var V, SecondV: Tvector;

i, N: integer; R: double;

begin

//Создание экземпляров класса

V:=Tvector.Create; SecondV:=Tvector.Create;

try

V.Length:=4; SecondV.Length:= 4;

for i:=0 to V.Length-1 do begin

Randomize; V[i]:=Random(100); end;

for i:=0 to SecondV.Length-1 do SecondV[i]:= 10; Memo1.Lines.add(V.AsString); V.Product(10);

Memo1.Lines.add(V.AsString); V.Add(SecondV); Memo1.Lines.Add(V.AsString);

R:=V.ScalarProduct(SecondV); Memo1.Lines.Add(FloatToStr(R));

finally

V.Free; SecondV.Free;

end;

end;

procedure Tform1.ButtonExitClick(Sender: Tobject);

begin

Close;

end;

end

Задания для самостоятельного выполнения

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

Условиями некорректности данных могут быть:

- запись в свойстве «Фамилия, Имя или Отчество» значения, которых начинается с маленькой буквы;

- запись в свойства «Дата рождения» даты, которая не входит в диапазон 15-50 лет в прошлом по отношению к нынешней дате.

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

2. Напишите программу просмотра картинок времен года. На форме расположите 4 кнопки RadioButton Зима, Весна, Лето, Осень. При нажатии на каждую из них на форму должна загружаться соответствующая картинка из каталога. Посмотрите, что произойдет, если, например, переместить картинку Лето в другой каталог. Доработайте программу таким образом, что если указанный файл не будет обнаружен, на форму будет загружаться любая стандартная картинка.

3. Создать программу, вычисляющую корни квадратного уравнения (ax²+bx+c=0). Необходимо поместить на форму четыре объекта класса TextBox - три для коэффициентов квадратного уравнения, один - для результата и кнопку (объект класса Button), нажимая на которую пользователь выполняет нахождение корней. Исключить ввод символов вместо цифр, получение отрицательного дискриминанта и ввод а = 0. Вывести при всех типах ошибок одно и то же сообщение.

Лабораторная работа № 3. Простейшие классы и объекты в С++

Цель работы. Изучение синтаксиса и особенностей реализации принципов объектно-ориентированного программирования в С+. Получение навыков применения объектно-ориентированного подхода при решении задач.

Теоретические сведения

Классы в С++ представляют абстрактные типы данных с открытым интерфейсом и скрытой внутренней реализацией. В классах реализованы базовые принципы объектно-ориентированного программирования (ООП):

- абстракция данных;

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

- наследование - в производных классах наследуются члены базового класса;

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

Определение простейшего класса без наследования имеет вид:

class имя_класса {

// по умолчанию раздел private - частные члены класса

public: // открытые функции и переменные класса

};

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

Переменные и функции, объявленные в разделе класса по умолчанию или явно как private, имеют область видимости в пределах класса. Их можно сделать видимыми вне класса, если объявить в разделе public:. Обычно переменные объявляются в разделе private, а функции в разделе public.

Классами в С++ являются также структуры (struct) и объединения (union). В отличие от класса члены структуры по умолчанию являются открытыми, а не закрытыми. Кроме того, объединения не могут наследоваться и наследовать.

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

тип имя_класса:: имя_функции (описание аргументов)

{ /*тело функции*/ }

Вызов функций осуществляется одним из двух способов:

имя_объекта.имя_функции(аргументы);

указатель_на_объект -> имя_функции(аргументы);

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

Функции-«друзья» класса, объявляемые в классе со спецификатором friend, указатель this не содержат. Объекты, с которыми работают такие функции, должны передаваться в качестве их аргументов. Это обычные функции языка С++, которым разрешен доступ к закрытым членам класса.

Пример 1.

#include <iostream>//1

using namespace std;//2

//3

class Number//4

{//5

private://6

int number;//7

public://8

void setNumber()//9

{//10

cout << "Введите число: ";//11

cin >> number;//12

}//13

//14

void getNumber() //15

{//16

cout << number << endl;//17

}//18

};//19

//20

int main()//21

{//22

setlocale(LC_ALL, "rus");//23

//24

Number object;//25

//26

object.setNumber();//27

object.getNumber();//28

//29

return 0;//30

}//31

В строках 4 -- 19 находится определение класса. Чтобы объявить класс надо использовать ключевое слово class и дать ему имя. В фигурных скобках описать его и, в конце поставить; точку с запятой.

Class ИмяКласса

{

//тело класса};

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

В теле класса (между фигурными скобками) могут находиться данные (переменные базовых типов и строки), функции, принадлежащие классу, структуры, классы. Всё это чаще называют членами или полями класса. Функции, которые объявлены и/или определены в теле класса -- это методы класса. Далее так их и будем называть. Просто надо запомнить: методы класса -- это функции, специально созданные для работы с данными (членами) этого класса.

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

Object.number = 11; //ошибка - доступ закрыт

Попытка обращения к закрытому члену класса из main-функции

Чтобы сделать данные «закрытыми» надо разместить их в поле private. По умолчанию, всё что объявлено в классе, становится закрытым от прямого доступа и доступно только для других членов или методов класса. Чтобы объявить открытые члены класса, надо применить ключевое слово public. В этом поле зачастую находятся методы класса, которые и будут работать с приватными (закрытыми) данными. Публичные (открытые) методы и другие члены класса доступны из любой другой части кода/программы, в которой определен класс.

#include <iostream> using namespace std; class Number { private: int number; public: void setNumber(); //прототипы void getNumber(); }; //~~~~~~~~~~~~~~~~~~~~~~~~~ void Number::setNumber() { cout << "Введите чиcло: "; cin >> number; } //~~~~~~~~~~~~~~~~~~~~~~~~~ void Number::getNumber() { cout << number << endl; } int main() { setlocale(LC_ALL, "rus"); Number object; object.setNumber(); object.getNumber(); return 0; }	//1 //2 //3 //4 //5 //6 //7 //8 //9 //10 //11 12 //13 //14 //15 //16 //17 18 //19 //20 //21 //22 //23 //24 //25 //26 //27 //28 //29 //30 //31 //32 //33 //34

Чтобы указать, что функция, определенная вне класса, является именно его методом, надо как-то связать имя класса с именем этого метода. Для этого пишем сначала тип возвращаемого значения, затем имя класса, далее операцию расширения области видимости: (двойное двоеточие), имя метода и скобки (с параметрами или без): void Number::setNumber() Потом, как обычно, следует определение тела функции в фигурных скобках.

Так как класс -- это некий тип, определённый программистом, то создав класс мы можем создавать объекты этого типа: Number object; Как мы обсудили раньше, мы не сможем обратиться к приватным членам класса из главной функции. Но мы легко можем с ними работать, через определённые методы класса. Так вызываем эти методы через объект и сначала присваиваем переменной number значение, а затем показываем на экран.

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

#include <iostream> using namespace std; class Children { char name[32]; // поля закрытые по умолчанию char surname[32]; int age; public: // открытые поля void fillData(); void showData(); }; int main() { setlocale(LC_ALL, "rus"); Children FirstChild; Children SecondChild; cout << "Внесите данные!\n"; FirstChild.fillData(); SecondChild.fillData(); FirstChild.showData(); SecondChild.showData(); return 0; } // определение методов класса void Children::fillData() { cout << "Имя: "; cin.getline(name, 32); cout << "Фамилия: "; cin.getline(surname, 32); cout << "Возраст: "; cin >> age; cin.get(); } //============================================ void Children::showData() { cout << name << " " << surname << " " << age << " лет;\n"; }	//1 //2 //3 //4 //5 //6 //7 //8 //9 //10 //11 //12 //13 //14 //15 //16 //17 //18 //19 //20 //21 //22 //23 //24 //25 //26 //27 //28 //29 //30 //31 //32 //33 //34 //35 //36 //37 //38 //39 //40 //41 //42 //43 //44 //45

Результат:

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

Конструктор (от construct - создавать) -- это особый метод класса, который выполняется автоматически в момент создания объекта класса. То есть, если мы пропишем в нем, какими значениями надо инициализировать поля во время объявления объекта класса, он сработает без «особого приглашения». Его не надо специально вызывать, как обычный метод класса.

Пример:

#include <iostream> using namespace std; class SomeData { private: int someNum1; double someNum2; char someSymb[128]; public: SomeData()//это конструктор: { someNum1 = 111;// присваиваем начальные //значения полям someNum2 = 222.22; strcpy_s(someSymb, "СТРОКА!"); cout << "\nКонструктор сработал!\n"; } void showSomeData() { cout << "someNum1 = " << someNum1 << endl; cout << "someNum2 = " << someNum2 << endl; cout << "someSymb = " << someSymb << endl; } } obj1;//уже на этом этапе сработает конструктор //(значения запишутся в поля) int main() { setlocale(LC_ALL, "rus"); obj1.showSomeData(); SomeData obj2;//тут сработает конструктор для //второго объекта класса obj2.showSomeData(); }	//1 //2 //3 //4 //5 //6 //7 //8 //9 //10 //11 //12 //13 //14 //15 //16 //17 //18 //19 //20 //21 //22 //23 //24 //25 26 //27 //28 //29 //30 //31 //32 //33 //34 //35

В строках 11 -- 17 определяем конструктор: имя должно быть идентично имени класса; конструктор НЕ имеет типа возвращаемого значения (void в том числе). Один объект объявляется сразу во время определения класса -- строка 25. При запуске программы, конструктор этого объекта сработает даже до входа в главную функцию. Это видно на следующем снимке:

программа еще не дошла до выполнения строки 29 setlocale(LC_ALL, "rus");, а конструктор уже «отчитался», что сработал (кириллица отобразилась некорректно). В строке 30 -- смотрим, что содержат поля класса. Второй раз конструктор сработает в строке 32, во время создания объекта obj2.

Деструктор (от destruct -- разрушать) -- так же особый метод класса, который срабатывает во время уничтожения объектов класса. Чаще всего его роль заключается в том, чтобы освободить динамическую память, которую выделял конструктор для объекта. Имя его, как и у конструктора, должно соответствовать имени класса. Только перед именем надо добавить символ ~

Добавим деструктор в предыдущий код. И создадим в классе два конструктора: один будет принимать параметры, второй -- нет.

#include <iostream> using namespace std; class SomeData { private: int someNum1; double someNum2; char someSymb[128]; public: SomeData() { someNum1 = 1; someNum2 = 1; strcpy_s(someSymb, "СТРОКА ПО УМОЛЧАНИЮ!"); cout << "\nКонструктор сработал!\n"; } SomeData(int n1, double n2, char s[]) { someNum1 = n1; someNum2 = n2; strcpy_s(someSymb, s); cout << "\nКонструктор с параметрами сработал!\n"; } void showSomeData() { cout << "someNum1 = " << someNum1 << endl; cout << "someNum2 = " << someNum2 << endl; cout << "someSymb = " << someSymb << endl; } ~SomeData() { cout << "\nДеcтруктор сработал!\n"; } }; int main() { setlocale(LC_ALL, "rus"); SomeData obj1(2, 3.4, "СТРОКА ПАРАМЕТР"); // сработает конструктор с параметрами obj1.showSomeData(); SomeData obj2;// сработает конструктор по умолчанию obj2.showSomeData(); }	1 //2 //3 //4 //5 //6 //7 //8 //9 //10 //11 //12 //13 //14 //15 //16 //17 //18 //19 //20 //21 //22 //23 //24 //25 //26 //27 //28 //29 //30 //31 //32 //33 //34 //35 //36 //37 //38 //39 //40 //41 //42 //43 //44 //45 //46 //47 //48 //49

Деструктор определен в строках 34 -- 37. Для простоты примера он просто отобразит строку в том месте программы, где сработает. Строка 43 -- объявляем объект класса и передаем данные для записи в поля. Тут сработает конструктор с параметрами. А в строке 46 -- сработает конструктор по умолчанию.

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



#include <iostream> using namespace std; class SetShowData { char someName[128]; int someAge; public: void enterData() { cout << "Ваше имя: "; cin.getline(someName, 128); cout << "Ваш возраст: "; cin >> someAge; } void showData() { cout<< "\n" <<someName<<" "<< someAge <<endl << endl; } }; int main() { setlocale(LC_ALL, "rus"); SetShowData objectOfClass; objectOfClass.enterData(); // вызов метода для ввода //данных objectOfClass.showData(); //вызов метода для //отображения данных return 0; }	//1 //2 //3 //4 //5 //6 //7 //8 //9 //10 //11 //12 //13 //14 //15 //16 //17 //18 //19 //20 //21 //22 //23 //24 //25 //26 //27 //28 //29 30 //31 //32

Указатель this хранит адрес определённого объекта класса. В рассмотренном примере он хранит адрес объекта objectOfClass. Таким образом он неявно указывает методам класса с данными какого объекта надо работать. Если бы мы определяли метод enterData() с явным использованием this, это выглядело бы так:



void enterData()

{

cout<<”Ваше имя: ”;

cin.getline(this->someName, 128);

cout<<”Ваш возраст: ”;

cin<<this->someAge;

}

Или так:

void enterData()

{

cout<<”Ваше имя: ”;

cin.getline((*this).someName, 128);

cout<<”Ваш возраст: ”;

cin>>(*this).someAge;

}

Конкретно в этих случаях можно обойтись и без явного использования this. Но иногда явного использования не избежать. К примеру в следующем примере, this не позволит компилятору запутаться в именах членов класса и параметров которые принимает конструктор C++.

#include <iostream> using namespace std; class SetShowData { char someName[128]; int someAge; public: // члены класса и одноименные параметры: SetShowData(char someName[], int someAge) { strcpy_s(this->someName, someName); this->someAge = someAge; } void showData() { cout << "\n" << someName << " " << someAge << endl << endl; } }; int main() { setlocale(LC_ALL, "rus"); SetShowData objectOfClass("Далер", 25); objectOfClass.showData(); return 0; }	//1 //2 //3 //4 //5 //6 //7 //8 9 //10 //11 //12 //13 //14 //15 //16 //17 //18 //19 //20 //21 //22 //23 //24 //25 //26 //27 //28 //29 //30

В строке 10 мы определили конструктор с параметрами, имена которых совпадают с именами членов класса: someName и someAge. Далее чтобы дать компилятору понять что именно и куда надо скопировать, мы явно используем указатель this:

this->someAge = someAge;//13

Это означает, что в член класса someAge необходимо записать значение, которое будет задано при создании объекта класса.

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

Задания для самостоятельного выполнения

1. Abiturient: Фамилия, Имя, Отчество, Адрес, Оценки. Создать массив объектов. Вывести:

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

в) выбрать N абитуриентов, имеющих самую высокую сумму баллов, и список абитуриентов, имеющих полупроходной балл.

2. Aeroflot: Пункт назначения, Номер рейса, Тип самолета, Время вылета, Дни недели. Создать массив объектов. Вывести:

а) список рейсов для заданного пункта назначения;

б) список рейсов для заданного дня недели;

в) список рейсов для заданного дня недели, время вылета для которых больше заданного.

3. Book: Автор, Название, Издательство, Год, Количество страниц. Создать массив объектов. Вывести:

а) список книг заданного автора;

б) список книг, выпущенных заданным издательством;

4. Worker: Фамилия и инициалы, Должность, Год поступления на работу, Зарплата. Создать массив объектов. Вывести:

а) список работников, стаж работы которых на данном предприятии превышает заданное число лет;

б) список работников, зарплата которых больше заданной;

5. Train: Пункт назначения, Номер поезда, Время отправления, Число общих мест, Купейных, Плацкартных. Создать массив объектов. Вывести:

а) список поездов, следующих до заданного пункта назначения;

б) список поездов, следующих до заданного пункта назначения и отправляющихся после заданного часа;

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

5. Product: Наименование, Производитель, Цена, Срок хранения, Количество. Создать массив объектов. Вывести:

а) список товаров для заданного наименования;

б) список товаров для заданного наименования, цена которых не превышает указанной;

в) список товаров, срок хранения которых больше заданного.

Лабораторная работа №4. Создание класса и объектов в среде программирования C#

Цель работы. Овладение возможностями программной среды C# для создания консольного приложения. Создание класса, объектов, и методов. Четко разграничить понятия класса, объекта.

Теоретические сведения.

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

Во всех объектно-ориентированных языках четко различаются понятия «класс» и «объект».

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

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

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

Единственный способ создания нового объекта в С# -- использовать ключевое слово new.

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

Класс.

С точки зрения синтаксиса, между объявлениями классов (class) и структур (struct) существуют незначительные различия:

- в структуре не допускается объявлений членов класса со спецификаторами доступа protected и protected internal;

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

Объявление класса состоит из нескольких элементов:

- объявление атрибутов - необязательный элемент объявления;

- модификаторы (в том числе модификаторы прав доступа) - необязательный элемент объявления;

- partial (спецификатор разделения объявления класса) - необязательный элемент объявления;

- class;

- имя класса;

- имена предков (класса и интерфейсов) - необязательный элемент объявления;

- тело класса.

Модификаторы прав доступа (см. табл.4.1.) обеспечивают реализацию принципа инкапсуляции, используются при объявлении классов и их составляющих компонентов.

Табл. 4.1. Модификаторы прав доступа членов класса.

public	обозначение для общедоступных членов класса. К ним можно обратиться из любого метода любого класса программы.
protected	обозначение для членов класса, доступных в рамках объявляемого класса и из методов производных классов.
internal	обозначение для членов класса, доступных из методов классов, объявляемых в рамках сборки, содержащей объявление данного класса.
protected internal	обозначение для членов класса, доступных в рамках объявляемого класса и из методов производных классов, а также доступных из методов классов, объявляемых в рамках сборки, содержащей объявление данного класса.
private	обозначение для членов класса, доступных в рамках объявляемого класса.

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

Атрибуты - средство добавления ДЕКЛАРАТИВНОЙ (вспомогательной) информации к элементам программного кода. Назначение атрибутов: организация взаимодействия между программными модулями, дополнительная информация об условиях выполнения кода, управление сериализацией (правила сохранения информации), отладка, многое другое.

В теле класса могут быть объявлены:

константы;

поля;

конструкторы и деструкторы;

методы;

свойства;

делегаты;

классы.

Из синтаксиса следует, что классы могут быть вложенными. Такая ситуация довольно редкая. Ее стоит использовать, когда некоторый класс носит вспомогательный характер, разрабатывается в интересах другого класса и есть полная уверенность, что внутренний класс никому не понадобится кроме класса, в который он вложен. Как уже упоминалось, внутренние классы обычно имеют модификатор доступа, отличный от public.

Основу любого класса составляют его конструкторы, поля и методы.

Поля класса

Поля класса синтаксически являются обычными переменными (объектами) языка. Их описание удовлетворяет обычным правилам объявления переменных.

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

...