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

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

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

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

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

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

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

Объект

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

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

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

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

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

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

VarPeople: TPeople; // описание объекта

При работе с обычными типами данных этого объявления было бы достаточно для получения экземпляра типа, но объекты среды Delphi являются динамическими данными, поэтому переменная People –просто ссылка на еще не существующий физически  (объект в памяти). Чтобы сконструировать объект (выделить память для экземпляра) класса TPeople и связать с ним переменную Peopleиспользуется People = TPeople.Create;

После этого объект можно использовать в программе: получать и устанавливать значения его полей, вызывать его методы.Доступ к полям и методам объекта происходит с помощью составных имён.(через «.» (People.GetAge;) иличерезwithPeopledoGetName<…>End;)

Если объект становится ненужным, он должен быть удалён вызовом специального метода Destroy (People.Destroy;    //Освобождение памяти, занимаемой объектом)

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

Класс

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

Определение класса:Typeв глобальном блоке, за которым следует имя класса, его поля и методы. По форме объявления классы похожи на обычные записи. В объявление класса могут входить и другие классы. Завершается описание словом end.Разрешеноопережающееобъявлениеклассов. Принято идентификаторы большинства классов начинать с символа "Т" (#TButton,TEdit).

Type

       TFamily = Class; //опережающее

       TPeople = Class

                       Name : String;

                   Age : 0..99;

                   Fam:TFamily;

ProcedureGetName;

ProcedureGetAge;

end;

           TFamily = Class(TObject); <…>

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

Отличие классов от других типов: объекты класса всегда располагаются в куче (Heap --структура данных, с помощью которой реализована динамически распределяемая память приложения, а также объём памяти, зарезервированный под эту структуру), поэтому объектная переменная фактически представляет собой лишь указатель на динамическую область памяти. Однако, при ссылке на содержимое объекта символ "^" не ставится:

VarPeople: TPeople;

Begin<…>

People ^.Age:= 20;//ошибкаописания

People.Age:= 20;

End;

Составляющие класса

В общем виде класс объявляется в разделе Type следующим образом:

Type

<имя класса> = class (<имя класса-родителя>)

       public

                   <описание общедоступных элементов>

       published

                   <описание элементов, доступных в Инспекторе Объектов>

       protected

                   <описание элементов, доступных в классах-потомках>

       private

                   <описание элементов, доступных только в модуле>

end;

где элемент = поля, методы, свойствя и события.

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

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

(#TForm инкапсулирует в себе все необходимое для создания Windows-окна, ТМеmо -- полнофункциональный текстовый редактор, а TTimer обеспечивает работу программы с таймером и т.д.) +представляет собой мощное средство обмена готовыми к работе

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

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

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

Если необходимо создать класс, являющийся непосредственным потомком класса TObject, то TSecondClass = Class (TObject) эквивалентно TSecondClass = Class;

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

Принцип наследования приводит к созданию ветвящегося дерева классов, постепенно разрастающегося при перемещении от TObject его потомкам.

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

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

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

Type

TBase = class

       ProcedureMyJoy;

end;

TDescedant = class (TBase)                            

       Procedure MyJoy;

end;

Var FirstObject : TBase; SecondObject : TDescedant;

Begin<…>

FirstObject.MyJoy; // вызывается метод, описанный в классе TBase.

SecondObject.MyJoy; // вызывается метод, описанный в классе TDescedant.

<…>End;

Поля

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

TypeTChildClass = class

FOne : Integer;

FTwo : String;

FThree : TObject;

end;

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

Исходя из принципа инкапсуляции, обращение к полям должно осуществляться при помощи методов и свойств класса. ВOP допускается и обращение напрямую к полям по составному имени (<объект>.<поле>): MyObject.FOne := 16;

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

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

Свойства

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

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

Метод доступа для чтения -функциейбезпараметров, возвращающая значение того же самого типа, что и свойство. Имя функции, предназначенной для чтения, принято начитать с приставки Get, после которой следует имя свойства.

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

Для объявления свойства используются зарезервированные слова property, read, write.

Слова read и write обозначают начала разделов, содержащих имена методов, предназначенных для чтения и записи соответственно.

TypeTStudent = class

FAge: integer;

Function GetAge: integer;

Procedure SetAge (Value: integer);

propertyAge : integer read GetAge write SetAge;

end;

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

Var GoodStudent: TStudent;HisAge: Integer;

Begin<…>

GoodStudent.Age := 19;

HisAge := GoodStudent.Age;

<…>End;

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

property Age : integer readFAge write SetAge;

Для ограничения начтение или запись при описании свойства опускаются разделы read или write.

property Age : integer read GetAge;

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

Методы

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

Например,

TypeTChildClass = class

       <всеполядометодов!>

       Function FirstFunc (x: real) : real;                                                  

       ProcedureSecondProc;

end;

Для обращения к методам -- составные имена:<имя объекта>.<имя метода >: MyObject.SecondProc.

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

Сами методы описываются вне определения класса как отдельная процедура или функция, именем <Класс>.<метод>

ProcedureTPerson.Init (Nm, Dt : String);

Begin

FName: = Nm;

FDate:= Dt;

end;

ProcedureInitуже другая процедура и может быть спокойно определена.

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

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

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

TypeTBase = class

       Procedure MyJoy; virtual;

end;

TDescedant = class (TBase)

       Procedure MyJoy; override;

end;

Абстрактные методы (abstract после virtual/dynamic)используют, когда не имеет смысла выполнять реализацию определенных методов базового класса, но метод обязан быть как у класса-наследника. Ими называются виртуальные или динамические методы, определенные в классе, но не содержащие никаких действий, никогда не вызываются и обязательно должны быть определены в классах-потомках.

ProcedureMyMetod; virtual;abstract;

Основное предназначение абстрактных методов – быть родоначальником иерархии конкретных методов в классах-потомках.

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

typeTlstObj = class

FExtData : Extended;

procedure SetData (AValue: Extended); overload; //статичские

end;

T2ndObj = class(TlstObj)

FIntData : Integer;

procedure SetData (AValue: Integer); overload;

end;

Теперь можно использовать обе реализацииSetData одновременно.

Можно перегрузить и виртуальный (динамический) метод с директивойreintroduce:

typeTlObj = class<…>

procedureSetData (AValue: Extended); overload; virtual;

end;

T2Obj = class (T1Obj) <…>

procedureSetData (AValue: Integer); reintroduce; overload;

end;

На перегрузку методов накладывается ограничение — нельзя перегружать методы, находящиеся в области видимости published, т. е. те, которые будут использоваться в Инспекторе объектов.

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

TypeTChildClass = class (TObject)

Class function ChildClassInfo : string;

End;

// описаниеметодакласса

classfunction GetSize: string;

Begin<…>End;

Var

       AString: string;

       MyObject: TMyObject;

classfunction GetSize: string;

end;

Var

MyObject: TMyObject; // экземпляркласса

AString: string;

begin<…>

AString : = TMyObject.GetSize; // безпорожденияобъекта

MyObject:= TMyObject.Create; // порождениеобъекта

AString : = MyObject.GetSize;    //послепорожденияобъекта

<…>end.

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