1.9 Виды наследования

Простое наследование: у класса не более одного класса- предка.

Класс, от которого произошло наследование, называется базовым или родительским (англ. base class). Классы, которые произошли от базового, называются потомками, наследниками или производными классами (англ. derived class).

В некоторых языках используются абстрактные классы. Абстрактный класс — это класс, который описан в программе, имеет поля, функции, но не используется для создания объекта. Объекты создаются только на основе производных классов, наследованных от абстрактного. Например, абстрактным классом может быть базовый класс «сотрудник ВУЗа», от которого наследуются классы «аспирант», «профессор» и т.д. Т.к. производные классы имеют общие поля и функции (например, поле «год рождения»), то эти члены класса могут быть описаны в базовом классе. В программе создаются объекты на основе классов «аспирант», «профессор», но нет смысла создавать объект на основе класса «сотрудник вуза».

 Множественное наследование: у класса произвольное количество классов-предков.

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

налогов. Наследование оправдано в обоих случаях. Множественное наследование (multiple inheritance) - это гарантия того, что класс может быть наследником не только одного класса, но многих, если это концептуально оправдано.

В этом примере производный класс Student_worker открыто наследует члены обоих базовых классов.

2.0 Статическое наследование

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

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

Перекрытие методов

Рассмотрим класс A, у которого имеется метод f(int), и класс B, унаследованный от A, у которого есть метод f(long):

struct A {         void f(int); }; struct B : A {         void f(long); };        

В следующем коде:

B b; b.f(1);        

произойдет вызов метода f(long) класса B, несмотря на то, что у родительского класса A есть более подходящий метод f(int). Оказывается, что метод f(int) родительского класса A перекрылся. Для того, чтобы в примере вызвался метод f(int), следует добавить строку using A::f; в определении класса B:

struct B : A {         using A::f;         void f(long); };        

1.11 Использование родительских полей, методов и свойств в дочернем классе.

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

Поля класса синтаксически являются обычными переменными (объектами) языка. Их описание удовлетворяет обычным правилам объявления переменных. Содержательно поля задают представление той самой абстракции данных, которую реализует класс. Поля характеризуют свойства объектов класса. Напомню, что когда создается новый объект класса (в динамической памяти или в стеке), то этот объект представляет собой набор полей класса. Два объекта одного класса имеют один и тот же набор полей, но разнятся значениями, хранимыми в этих полях. Все объекты классаPersonмогут иметь поле, характеризующее рост персоны, но один объект может быть высокого роста, другой – низкого, а третий – среднего роста. Поля содержат данные объекта

Методы – определяют действия, которые объект способен выполнять. Метод — это фрагмент кода, к кот можно обратиться по имени. Он описывается один раз, а вызываться может столько раз, сколько необходимо.

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

Любой метод содержит одну или несколько инструкций. Каждый метод имеет имя, и именно это имя используется для его вызова. В общем случае методу можно присвоить любое имя. Имена методов сопровождаются парой круглых скобок. Например, если метод имеет имя getval, то в тексте будет написано getval (). Это помогает отличать имена переменных от имен методов.

Запись метода: доступ тип_возврата имя (список_параметров) {// тело метода}

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

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

[модификатор доступа] <тип> <Имя>

{

Get

{ Блок для чтения из поля }

Set

{ Блок для записи в поле}

}

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

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

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

В иерархии производный объект наследует разрешенные для наследования компоненты всех базовых объектов (public, protected).

В иерархии классов соглашение относительно доступности компонентов класса следующие:

private – Член класса может использоваться только функциями-членами данного класса и функциями-"друзьями" своего класса. В производном классе он недоступен.

protected – То же, что и private, но дополнительно член класса с данным атрибутом доступа может использоваться функциями-членами и функциями-"друзьями" классов, производных от данного.

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

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

1.12 Форма, как наследник класса TFORM

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

Delphi использует концепцию форм в классе TForm, и каждая форма, создаваемая с помощью конструктора форм (Form Designer), наследует основные свойства, методы и события этого класса.

Класс TForm предоставляет возможность изменять поведение и внешний вид формы с помощью ряда свойств, методов и событий.

Одним из предков класса TForm является класс TWinControl, поэтому все свойства этого класса наследуются формой

Форма может быть модальной и немодальной. Немодальная форма позволяет переключиться в другую форму приложения без своего закрытия. Модальная форма требует обязательного закрытия перед обращением к любой другой форме приложения.

Используя принципы ОПП, мы можем сказать, что, так как TForm представляет собой класс, он может повторно использоваться, расширяться и изменяться. Повторное применение форм поддерживается через шаблоны форм и наследование. Оба эти метода используют Object Repository

Шаблоны форм

Шаблоны форм (Form Templates) предоставляют основу для новой формы. По одной заготовке можно создать несколько форм. В Delphi есть хранилище объектов (Object Repository), в котором содержится множество различных шаблонов форм, диалогов и проектов.

Использование шаблонов форм

Приведенные ниже опции позволяют использовать шаблоны форм.

Copy. Эта опция добавляет копию шаблона формы в ваш проект. Изменения объекта в проекте не влияют на другие объекты.

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

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

Наследование позволяет создать множество экземпляров шаблона, которые могут отличаться один от другого, как при использовании Copy. Оно так же автоматически вносит изменения в объект хранилища, как и при использовании Use.

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

1.13 . Базовые классы для компонент: визуальных, не визуальных, оконных.

Библиотека визуальных компонентов (Visual Component Library, VCL) содержит большое количество классов, предназначенных для быстрой разработки приложений. Все классы VCL расположены на определенном уровне иерархии классов

Компонентами называются экземпляры классов, которые являются потомками класса TComponent. Экземпляры всех других классов называются объектами. Класс TComponent является важнейшим для всех компонентов. Непосредственно от него можно создавать любые невизуальные компоненты. Механизмы, реализованные в классе TComponent, обеспечивают взаимодействие компонента со средой разработки, главным образом с Палитрой компонентов и Инспектором объектов. Благодаря возможностям этого класса, компоненты начинают работать на форме проекта уже на этапе разработки. В VCL содержатся невизуальные и визуальные компоненты, а также другие классы, начиная с абстрактного класса TObject. Для большинства визуальных компонентов базовым является класс TControl. Класс TControl происходит от класса TComponent. Его основное назначение — обеспечить функционирование визуальных компонентов. Каждый визуальный компонент, произошедший от TControl, наделяется основными признаками элемента управления. Благодаря этому, каждый визуальный компонент умеет работать с GUI (Graphic User Interface — графический интерфейс пользователя ОС) и отображать себя на экране.

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

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

«Оконные» компоненты (windowed controls) являются специализированными окнами внутри окна формы. Их самое главное качество — способность получать фокус ввода. К числу оконных компонентов относятся, например, компоненты Button, RadioButton, CheckBox, GroupBox, и т.д. Класс TWinControl обеспечивает использование в Delphi оконных элементов управления. Главное отличие оконного элемента управления от любых других — наличие дескриптора окна hwnd. Дескриптор окна — это специальный идентификатор, который операционная система присваивает всем объектам, которые должны обладать свойствами окна. Если элемент управления имеет дескриптор окна, то он должен уметь выполнять следующие операции:

• получать и передавать фокус управления во время выполнения приложения;

• воспринимать управляющие воздействия от мыши и клавиатуры;

• уметь размещать на себе другие элементы управления.

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

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

1.14 Основные поля, методы и свойства, используемые в визуальных, не визуальных и оконных компонентах.

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

Визуальные компоненты имеют ряд общих свойств:

Left иTop — местоположение визуального компонента внутри формы (или внутрикомпонента-владельца).

BiDiMode — позволяет сделать так, чтобы текст читался справа налево (используется при работе с восточными языками).

Caption — надпись компонента.

Color — цвет компонента. Компонент либо использует свой собственный цвет, либо копирует цвет содержащего компонента. Это определяется значением свойстваParentColor. Если свойство ParentColor имеет значение True, то цвет вложенного компонента (например, кнопки) при изменении станет такой же, как цвет у содержательного компонента (например, формы). Однако, если вы измените значение свойства Color, то свойство ParentColor автоматически примет значение False, и компонент получит свой собственный цвет.

Cursor — определяет, какой вид принимает указатель мыши, когда пользователь наводит его на компонент.

Font — шрифт надписи на компоненте.

Enabled — определяет, доступен ли компонент для пользователя. Если свойство имеет значение True, то компонент доступен, а если значение False, то недоступен.

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

Visible — определяет видимость компонента на экране. Если свойство имеет значение True, то компонент виден, а если значение False, то — не виден.

Общие события визуальных компонентов

Визуальные компоненты имеют ряд общих событий:

OnClick — происходит в результате щелчка мыши по компоненту.

OnDblClick — происходит в результате двойного щелчка мыши по компоненту.

OnKeyDown — происходит при нажатии пользователем любой клавиши (если компонент обладает фокусом ввода). При отпускании нажатой клавиши происходит событиеOnKeyUp.

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

OnEnter — происходит при получении компонентом фокуса ввода. Когда компонент теряет фокус ввода, происходит событиеOnExit. События OnEnter и OnExit не происходят при переключении между формами и приложениями.

1.15 Понятие замещения

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

Замещение реализуется в инкапсуляции. Полиморфизм заключается в том, что одно и то же имя может соответствовать различным действиям в зависимости от типа объектаКратко смысл полиморфизма можно выразить фразой: «Один интерфейс, множество реализаций».

Слово «полиморфизм» можно перевести как «много форм». В ОО программировании этим термином обозначают возможность использования одного и того же имени операции или метода к объектам разных классов, при этом действия, совершаемые с объектами, могут существенно различаться. Поэтому можно сказать, что у одного и того же слова много форм. Например, два разных класса могут содержать метод draw, однако инструкции в методах могут предусматривать совершенно разные операции: так в классе circle – это «код, рисующий именно круг», а в square – «код, рисующий именно квадрат». В зависимости от того, к объекту какого класса применяется метод draw, выполняются те или иные инструкции.

class Фигура:

virtual void draw();

class Круг : public Фигура:

virtual void draw() {

// код рисующий круг

}

class Квадрат : public Фигура:

virtual void draw() {

// код рисующий квадрат

}

У Вас есть множество фигур, но каждая выглядит по своему. Тем не менее каждую можно нарисовать. Получается, что изучая множество объектов, вы выделяете общие для всех свойства и действия и формируете "Абстракцию", в данном примере "Фигура". Когда Вы обобщили и сформулировали абстракцию в коде, настает время описать детали о Круге и Квадрате. Когда Вы пишите draw() для квадрата , то Вы замещаете код написанный в "Фигуре". Таким образом Вы переходите от общего к частному.

В классе фигура метод draw() объявлен как виртуальная функция.

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

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

1.16 Замещение, как основной способ создания собственных элементов объектов.

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

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

1.17. Статическое замещение

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

полиморфизм, обеспечивающий возможность задания различных

реализаций некоторого единого по названию метода для классов различных

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

имеющие одинаковое название - статическими полиморфными.

Простой полиморфизм (класс Окио_с_текстом). Пусть

необходимо разработать на базе класса Окно класс Окностекстом. Для этого

к полям класса Окно необходимо добавить специальные поля для определения

координат первой буквы текста - Xt, Yt и поле, содержащее сам текст - Text.

Кроме этого, понадобится специальный метод, который будет обрабатывать

сообщение «Нарисовать». Однако у нас уже существует родительский метод

Изобразить (!), который обрабатывает это сообщение. Следовательно,

необходимо заменить родительский метод методом потомка. Механизм

полиморфизма позволяет для класса-потомка Окно_с_текстом предусмотреть

собственный метод Изобразить (рис. 1.21).

Метод Инициализировать также должен бьггь переопределен, так как

он должен инициализировать дополнительные поля класса.

Класс Окно_с_текстом - родитель: класс Окно:

поля Xt, Yt, Text

метод Инициализировать (aXl,aYl,aX2,aY2,aColor,aXt, aYt, aText)

метод Изобразить

Конец описания.

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

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

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

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

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

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

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

1.18 Особенности работы со статически замещенными методами.

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

Статические методы

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

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

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

С++

class Фигура:

virtual void draw();

class Круг : public Фигура:

virtual void draw() {

// код рисующий круг

}

class Квадрат : public Фигура:

virtual void draw() {

// код рисующий квадрат

}

У Вас есть множество фигур, но каждая выглядит по своему. Тем не менее каждую можно нарисовать. Получается, что изучая множество объектов, вы выделяете общие для всех свойства и действия и формируете "Абстракцию", в данном примере "Фигура". Когда Вы обобщили и сформулировали абстракцию в коде, настает время описать детали о Круге и Квадрате. Когда Вы пишите draw() для квадрата , то Вы замещаете код написанный в "Фигуре". Таким образом Вы переходите от общего к частному.

В классе фигура метод draw() объявлен как виртуальная функция.

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

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

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

Статические методы всегда следует вызывать через имя класса, в котором они объявлены, Вызов статических методов через объект считается нетипичным и нарушающим смысл статического определения

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

Обращение к полям, методам и свойствам классов в программе и через инспектор объектов.

1.19 Обращение к полям, методам и свойствам классов в программе и через инспектор объектов.

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

Свойства объекта определяют его характеристики и поведение. Например, для объекта форма (окно) свойство Caption определяет название в виде текста, которое будет отображаться в верхней части окна, Color задает цвет окна, Width – его ширину и т. д. Свойства объекта можно менять при помощи инспектора объектов Инспектор объектов содержит две вкладки: Свойства (Properties) и События (Events). Свойства отображает доступные для управления свойства того или иного объекта. События отображает перечень событий, связанных с объектом.

В разделе класса _published объявляются опубликованные свойства. Этот раздел могут иметь только классы, производные от TObject.

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

Объект, для которого требуется изменить свойства, можно выбрать, щелчком мыши на самом объекте или выбрав его из списка в верхней части Инспектора объектов. Каждое свойство объекта имеет имя (которое нельзя изменить), например, «COLOR» и значение, которое можно изменить, например «red». Таким образом, через инспектор объектов можно настроить объект требуемым образом, не прибегая к программированию.

Свойства объекта можно менять и в самой программе. Для обращения к свойству объекта в программе записывают имя объекта и имя свойства, разделенные знаком—> (стрелка), например, для объекта c именем Form1 обращение к свойству Caption выглядит так: Forml->Caption="Суперпрограмма!";

Суперпрограмма! - значение свойства. После использования данного оператора в программе название окна формы будет Суперпрограмма! С помощью изменения значения свойства Visible можно управлять Видимостью окна: Forml->Visible=false; Forml->Visible=true; Первый оператор делает окно невидимым, второй заставляет окно вновь появиться.

Другим важным средством управления объектами являются методы. Методы представляют собой функции, которые можно вызывать для управления объектами. Например, для того чтобы окно стало невидимым, можно вызвать следующий метод: Forml->Hide(); Чтобы сделать окно вновь видимым, надо вызвать другой метод: Forml->Show(); Полный перечень свойств и методов объекта из библиотеки VCL приводится в документации и во встроенной справочной системе Borland C++ Builder.

Третье средство управления объектами — это события. Для каждого объекта существует свой перечень событий, содержащихся на вкладке Events. Каждое событие, также как и каждое свойство имеет неизменное имя и значение, которое можно изменить. Используя вкладку Events инспектора объектов, можно изменить реакцию объекта на то или иное событие. Для этого необходимо в инспекторе объектов выбрать нужное событие и дважды на его значении щелкнуть мышью. После этого открывается окно редактора кода, с автоматически созданной заготовкой функции, которая будет вызываться при возникновении данного события. Программисту остается написать код тела этой функции. Визуально пример изменения стандартной обработки события активизации окна показан на Рис. 3. Рис. 3. Изменение стандартной обработки события Лекция 24 5 С каждым объектом связано событие «по умолчанию». Например, для объекта Button (Кнопка) событие «по умолчанию» - Click (Щелчок). Событие «по умолчанию» содержится первым на вкладке Events. Если дважды щелкнуть мышью на самом объекте, то открывается окно редактора кода, с автоматически созданной заготовкой, куда вписывается тело функции, которая будет вызываться при возникновении события «по умолчанию». Редактор форм позволяет визуально разместить на форме с помощью мыши требуемые объекты. Редактор кода представляет собой текстовый редактор, позволяющий программисту создавать фрагменты кода программы, чтобы запрограммировать поведение созданных объектов приложения.

1.20-21 Методы класса. Особенности объявления и работы с ними.

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

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

Любой метод содержит одну или несколько инструкций. Каждый метод имеет имя, и именно это имя используется для его вызова. В общем случае методу можно присвоить любое имя. Имена методов сопровождаются парой круглых скобок. Например, если метод имеет имя getval, то в тексте будет написано getval (). Это помогает отличать имена переменных от имен методов.

Запись метода: доступ тип_возврата имя (список_параметров) {// тело метода}

Если задан тип метода (кроме void), то последним оператором тела метода должен быть оператор return, возвращающий результат работы метода.

Если перед методом указан тип void, то метод не должен возвращать результат своей работы с помощью оператора return (оператор return в этом случае отсутствует в теле метода).

Доступ к методам

Каждый метод имеет модификатор доступа, принимающий одно из четырех значений:public,private,protected. Атрибутом доступа по умолчанию является атрибут private. Независимо от значения атрибута доступа все методы доступны для вызова при выполнении метода класса. Если методы имеют атрибут доступа private, возможно опущенный, то тогда они доступны только для вызова только внутри методов самого класса. Такие методы считаются закрытыми. Понятно, что класс, у которого все методы закрыты, абсурден, поскольку никто не смог бы вызвать ни один из его методов. Как правило, у класса есть открытые методы, задающие интерфейс класса, и закрытые методы. Интерфейс – это лицо класса, именно он определяет, чем класс интересен своим клиентам, что он может делать, какие сервисы предоставляет клиентам. Закрытые методы составляют важную часть класса, позволяя клиентам класса не вникать во многие детали реализации класса. Эти методы клиентам класса недоступны, они о них могут ничего не знать, и, самое главное, изменения в закрытых методах класса никак не отражаются на клиентах класса при условии корректной работы открытых методов класса.

Рассмотрим пример:

Class X {

Public:

int m; // данные-члены

int mf (int v) { int old = m; m=v; return old; } // функция-член

};

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

назьюать методами. Для доступа к членам класса используется синтаксическая конструкция вида объект.член. Например:

X var; // var – переменная типа Х

Var.m = 7: // присваиваем значение члену m обьекта var

Int x = var.mf (9); // вызываем функцию-член mf() обьекта var

Поля класса всегда описьгоаются внутри класса. В отличие от полей,

компонентные функции могут быть описаны как внутри, так и вне определения

класса. В последнем случае определение класса должно содержать прототипы

этих функций, а заголовок функции должен включать описатель видимости,

который состоит из имени класса и знака «::». Таким способом компилятору

сообщается, что определяемой функции доступны внутренние поля класса:

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

{<тело компонентной функции>}

1.21-24 Объект исключительной ситуации. Понятие глобального обработчика исключительных ситуаций.

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

Исключительная ситуация – это некоторое ошибочное состояние, возникающее во время выполнения программы. Исключительные ситуации (исключения) могут возникать по самым разным причинам, например из-за невозможности выполнить преобразование, при делении на ноль и др. В любом случае приложение получает сообщение о возникновении исключения.

В Delphi предусмотрен глобальный обработчик исключительных ситуаций и могут быть задействованы локальные обработчики. Глобальная обработка исключений реализуется через объект Application. Глобальная обработка обеспечивает пользователя информацией об ошибке, но не устраняет причины. Если в каком либо методе не отловлено исключение, то оно будет обработано процедурой глобального обработчика исключений.

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

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

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

Для обозначения начала защищенного участка кода используется служебное слово try, завершается конструкция словом end. Существует два типа защищенных участков: try...except и try...finally, которые имеют похожий синтаксис, но отличаются по назначению. Первый тип используется для обработки исключительных ситуаций. Его синтаксис:

try

{Операторы, выполнение которых может вызвать ошибку}

except

{Операторы, которые должны быть выполнены в случае ошибки}

end;

Конструкция try...except применяется для перехвата исключительной ситуации и позволяет восстановить работоспособность программы. Секция except может быть разбита на несколько частей on...do для обработки разных классов исключений. После конструкций on...do может быть помещён раздел else, который относится ко всему блоку. По логике работы группа конструкций on...do напоминает оператор case. К исключениям, не имеющим своих локальных обработчиков, применяется механизм глобальной обработки через объект Application.

try

{Операторы, выполнение которых может вызвать ошибку}

except

{ераторы, которые должны быть выполнены в случае ошибки}

Оп on Exception1 do ...;

on Exception2 do ...;

...

else

.end;

..

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

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

procedure TForm1.Button1Click(Sender: TObject);

Var a,b:integer;

rbegin

ez:extended;

try

a:=strtoint(Edit1.Text);

b:=strtoint(Edit2.Text);

rez:=a/b;

Edit3.Text:=floattostr(rez);

except

ShowMessage('Ошибка!');

end;

Memo1.Lines.Add(Edit1.Text);

Memo1.Lines.Add(Edit2.Text);

Memo1.Lines.Add(inttostr(a+b));

Memo1.Lines.Add(floattostr(rez));

end;

В этом случае при возникновении любого исключения будет прерываться выполнение операторов защищённого блока, и результат не появится. На экран будет выведено окно с сообщением «Ошибка!». Операторы, расположенные после защищённого блока, будут выполняться, то есть в Memo1 появятся записи.

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

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

try

...{Операторы, выполнение которых может вызвать ошибку}

finally

{Операторы, которые должны быть выполнены даже в случае ошибки}

end;

Конструкцию try...finally можно включить в блок try...except. Это позволяет выполнить обязательные операторы секции finally и обработать исключение операторами секции except. Оба типа конструкций можно использовать в любом месте, допускается вложенность любой глубины.

Использование этих конструкций позволяет выделить операторы

обработки исключений в особые группы.

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

(exception) Вторая конструкция используется, если при возникновении исключения необходимо выполнить специальные действия, которые аннулируют последствия возникновения исключительной ситуации.

Создание и настройка глобального обработчика исключения на событии TApplication.OnException.

////////////////////////////////////////////////////////////////////////////////

// Автоматическое создание глобального обработчика исключения

////////////////////////////////////////////////////////////////////////////////

initialization

ExceptHandler := TExceptHandler.Create;

Application.OnException := ExceptHandler.OnException;

end.

Базовым классом для всех исключений является класс Exception. Основное н а з н а ч е н и е класса исключения — идентификация групп ошибок: отнесение исключения к тому или другому классу определяет способ обработки данного исключений.

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

2.1-2.2 Классификация языков и граммати. Примеры классификации языков и грамматик.

От того, к какому типу относится тот или иной язык программирования,

зависит сложность распознавателя для этого языка. Для некоторых типов

языков в принципе невозможно построить компилятор, который анализировал

бы исходные тексты на этих языках за приемлемое время на основе

ограниченных вычислительных ресурсов.