Главна информация

OOP е стил на програмиране, който се появява през 80-те години на 20 век. За разлика от процедурните езици, където данните и инструкциите за тяхната обработка съществуват отделно, в обектно-ориентираното програмиране тази информация се комбинира в едно цяло.

Основни принципи на ООП

Наследство

Вторият принцип на ООП, наследяването, е способността на един клас да използва методите на друг, без да повтаря реалната им реализация. Наследяването ви позволява да се отървете от излишъка в изходния код.

Полиморфизъм

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

ООП езици

OOP принципите се използват в най-популярните езици за програмиране като C++ и Java, в които се разработват значителна част от програмите и приложенията. Има и по-малко използвани OOP езици - Delphi, Object Pascal, Ruby и много други.

Критика към ООП

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

Първо, трудността на прехода. Ще отнеме доста време, за да разберете принципите на ООП, особено за хора, които работят тясно само с процедурни езици за програмиране.

Второ, недостатъкът е по-сложната документация, тъй като ще е необходимо не само да се опишат класове и обекти, но и конкретни случаи на тяхното внедряване.

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

Базира се на представянето на програма като набор от обекти. Всеки обект принадлежи към клас, който от своя страна заема своето място в наследената йерархия. Използването на OOP минимизира излишните данни, което подобрява контролируемостта и разбирането на програмата.

Какво е ООП

Възниква в резултат на развитието на процедурното програмиране. В основата на обектно-ориентираните езици са следните принципи:

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

Някои принципи, които първоначално бяха заложени в първия OYA, претърпяха значителни промени.

Примери за обектно-ориентирани езици:

1. Паскал. С пускането на Delphi 7, той официално стана известен като Delphi. Основната област на използване на Object Pascal е писането на приложен софтуер.
2. C++ се използва широко за разработка на софтуер и е един от най-популярните езици. Използва се за създаване на ОС, приложни програми, драйвери на устройства, приложения, сървъри, игри.
3. Java - преведен в байт код, обработен от виртуалната машина на Java. Предимството на този метод на изпълнение е неговата независимост от операционната система и хардуера. Съществуващи семейства: Standard Edition, Enterprise Edition, Micro Edition, Card.
4. JavaScript се използва като скриптов език за уеб страници. Синтаксисът е много подобен на C и Java. Е реализация на Ecmascript. Самият Ecmascript се използва като основа за изграждане на други, като JScript, ActionScript.
5. Objective-C е изграден на езика C и самият C код е разбираем от компилатора на Objective-C.
6. Perl е интерпретиран, динамичен език с общо предназначение на високо ниво. Има богати възможности за работа с текст и първоначално е проектиран специално за работа с текст. Сега се използва в системна администрация, разработка, мрежово програмиране, биоинформатика и др.
7. PHP. Съкращението се превежда като хипертекстов препроцесор. Използва се за разработване на уеб приложения, по-специално сървърната част. С негова помощ можете да създавате GUI приложения, използвайки WinBinder пакети.
8. Python е език с общо предназначение, фокусиран върху подобряване на производителността на разработчиците и четливостта на кода. Разработен е проектът Cython, с помощта на който програми, написани на Python, се превеждат в код на езика C.

Абстракция

Всяка книга като „Обектно-ориентирано програмиране за манекени“ подчертава един от основните принципи - абстракцията. Идеята е да се разделят детайлите или характеристиките на изпълнението на програмата на тези, които са важни и тези, които не са. Необходим за големи проекти, той ви позволява да работите на различни нива на представяне на системата, без да уточнявате подробности.

Абстрактен тип данни се представя като интерфейс или структура. Позволява ви да не мислите за нивото на детайлност на изпълнението. ADT е независим от другите кодови секции.

Известният афоризъм на Дейвид Уилър гласи: Всички проблеми в компютърните науки могат да бъдат решени на друго ниво на абстракция.

Наследство

Обектно-ориентираните езици са наследими - това е един от най-важните принципи.

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

Има няколко вида наследство:

• просто;
• множествено число.

При множественото наследяване може да има няколко деца от един прародител, докато при простото наследяване може да има само едно. Това е основната разлика между видовете.

Наследяването изглежда така:

функция draw() (

върнете "просто животно";

функция яде() (

връщане "животното яде";

клас крава разширява животно (

функция draw() (

Върнете "нещо, което прилича на крава";

Виждаме, че класът Cow е наследил всички методи от класа Animal. Сега, ако изпълним Cow.eat(), получаваме "животното яде", така че методът draw() се променя. Cow.draw() ще върне „нещо, което прилича на крава“, а Animal.draw() ще върне „просто животно“.

Капсулиране

Капсулирането ограничава достъпа на компоненти до други, свързва данните с методи за обработка. Спецификаторът за частен достъп се използва за капсулиране.

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

функция __construct($name) (

$това->име = $име;

функция getName() (

връща $това->име;

Името се приема като аргументи на конструктора. Когато конструкторът се използва в други части на кода, нищо няма да може да промени елемента име. Както можете да видите, той е посочен вътрешно; не е наличен за други части на кода.

Полиморфизъм

Полиморфизмът ви позволява да използвате едно и също име за решаване на подобни, но технически различни проблеми.

Примерът по-горе съдържа таблица. Виждаме клас CardDesk и клас GraphicalObject. И двете имат функция, наречена draw(). Той изпълнява различни действия, въпреки че има същото име.

Ad hoc полиморфизъм или специален полиморфизъм използва:

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

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

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

„Един интерфейс, много реализации“ Bjarne Stroustrup.

Клас

Класът е тип данни, който се състои от един набор от полета и методи.

Има вътрешен и външен интерфейс за управление на съдържанието. При копиране чрез присвояване се копира интерфейсът, но не и данните. Различните видове взаимодействат помежду си чрез:

• наследство;
• асоциации;
• агрегиране.

При наследяване дъщерният клас наследява всички свойства на родителя; асоциирането предполага взаимодействие на обекти. Когато обект от един клас е включен в друг, това се нарича агрегиране. Но когато те все още зависят един от друг по отношение на живота си, това е композиция.

Една от основните характеристики е обхватът. Концепцията се дефинира по различен начин в различните езици.

В Object Pascal това е описано по следния начин:

Име на клас = клас (Суперклас)

(използването на елементи е ограничено само в рамките на модула)

(тук са посочени полетата)

(спецификаторът за достъп стана достъпен с Delphi 2007, което означава същото като private)

(елементите могат да се използват вътре в ClassName или при наследяване)

(елементите са достъпни за всички, те се показват в инспектора на обекти)

Тук SuperClass е предшественикът, от който възниква наследяването.

За C++ създаването изглежда така:

клас MyClass: публичен родител

Моят клас(); // конструктор

~Моят клас(); // деструктор

В този пример Parent е предшественикът, ако има такъв. Спецификаторите private, public, protected означават същото като в предишния пример в Pascal. Виждаме също конструктор и деструктор, налични за всяка част от програмата. В C++ всички елементи са лични по подразбиране, така че това може да се пропусне.

Характеристики на изпълнение

В центъра на обектно-ориентираните езици е обектът, той е част от класа. Състои се от:

• полета;
• метод.

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

Методът е набор от функции, които дефинират всички възможни действия, които могат да бъдат извършени върху даден обект. Всички обекти си взаимодействат чрез извикване на методите на другия. Те могат да бъдат външни или вътрешни, което се определя от модификаторите за достъп.

ООП методологии

Съществуват следните методологии:

• Компонентно-ориентирано програмиране;
• Програмиране на прототипи;
• Класово-ориентирано програмиране.

Компонентно-ориентираното програмиране се основава на концепцията за компонент - компонент на програма, който е предназначен да бъде повторно използван. Реализира се като набор от структури с обща характеристика, правила и ограничения. Подходът се използва в обектно-ориентирания език Java, където ориентацията на компонентите се реализира чрез „JavaBeans“, написани по същите правила.

В прототипното програмиране няма концепция за клас - наследяването се постига чрез клониране на съществуващ прототип. Той е в основата на обектно-ориентираните езици javascript и други диалекти на ecmascript, както и lua или lo. Основните функции:

• потомците не трябва да запазват структурно сходство с прототипа (във връзката клас-инстанция точно това се случва);
• при копиране на прототип всички методи се наследяват едно към едно.

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

Обектно-ориентирани езици

Всички ООП отговарят напълно на принципите на ООП – елементите са обекти, които имат свойства. В този случай може да има допълнителни средства.

OOYA задължително съдържа набор от следните елементи:

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

В допълнение към горния списък могат да се добавят допълнителни инструменти:

• конструктор, деструктор, финализатори;
• Имоти;
• индексатори;
• модификатори за достъп.

Някои OYA отговарят на всички основни елементи, други частично. Трети са хибридни, тоест комбинирани са с подсистеми на други парадигми. Като цяло принципите на ООП могат да се приложат и към необектно-ориентиран език. Въпреки това, използването на OTL все още не прави кода обектно-ориентиран.

Езиковите езици поддържат повече от една парадигма. Например PHP или JavaScript поддържат функционално, процедурно, обектно-ориентирано програмиране. Java работи с пет парадигми: обектно-ориентирана, обща, процедурна, аспектно-ориентирана, едновременна. C# се счита за един от най-успешните примери за мултипарадигмизъм. Той поддържа същите подходи като Java, с добавяне на отразяваща парадигма, добавена към списъка. Език като Oz е проектиран да обединява всички концепции, традиционно свързани с различни софтуерни парадигми.

Абстрактни типове данни

Концепцията за абстрактни типове данни е ключова в програмирането. Абстракцията предполага отделяне и независимо разглеждане на интерфейса и изпълнението.

Нека разгледаме един пример. Всички гледаме телевизионни програми. Нека наречем телевизора модул или обект. Този обект има интерфейс с потребителя, т.е. контроли (набор от бутони), възпроизвеждане на изображение и звук. Колкото по-напреднал е интерфейсът, толкова по-удобен е телевизорът за използване. Превключваме програмите чрез натискане на определени бутони и в същото време не мислим за физическите процеси, протичащи в телевизора. Експертите знаят за това. Когато избираме телевизор, ние се интересуваме от неговата цена и параметри на производителност, т.е. качество на изображението, звука и т.н. Но не се интересуваме от това какво има вътре. С други думи, връщаме се към свойствата на обекта (модула), които са интерфейс и имплементация. Основната цел на абстракцията в програмирането е именно да отдели интерфейса от имплементацията.

Да се ​​върнем към нашия пример. Да предположим, че някой субект е уверен, че познава добре структурата на телевизора. Той премахва капака и започва да го „подобрява“. Въпреки че понякога това води до някои междинни (локални) успехи, крайният резултат почти винаги е отрицателен. Следователно подобни действия трябва да бъдат забранени. В програмирането това се поддържа от механизми за отказ на достъп или скриване на вътрешни компоненти. На всеки обект (модул) е дадено правото да управлява „собствената си собственост“, т.е. тези функции и операции. Пренебрегването на този принцип нарушава стабилността на системата и често води до нейното пълно разрушаване. Принципът на абстракцията изисква използването на механизми за скриване, които предотвратяват умишлено или случайно модифициране на вътрешни компоненти.

Абстракцията на данни включва дефиниране и разглеждане абстрактни типове данни(ATD) или, което е същото, нови типове данни, въведени от потребителя.

Абстрактен тип данние колекция от данни заедно с много операции, които могат да бъдат извършени върху тези данни.

Концепция за обектно-ориентирано програмиране

Според дефиницията на авторитет в областта на обектно-ориентираните методи за разработка на програми, Гради Буча, „обектно-ориентираното програмиране (ООП) е методология за програмиране, която се основава на представянето на програма като колекция от обекти, всеки от които е имплементация на определен клас (специален вид тип), а класовете образуват йерархия на принципите на наследимостта.“

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

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

Както знаете, един от принципите на управление на сложността на проекта е декомпозицията. Гради Бух разграничава два вида декомпозиция: алгоритмична (както той нарича декомпозиция, поддържана от структурни методи) и обектно-ориентирана, разликата между които според него е следната: „Разделението по алгоритми концентрира вниманието върху реда на случващите се събития , а разделянето по обекти придава особено значение на факторите, които предизвикват действия или са обект на прилагане на тези действия.

С други думи, алгоритмичната декомпозиция отчита повече структурата на връзките между части от сложен проблем, докато обектно-ориентираната декомпозиция обръща повече внимание на природата на връзките.

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

OO програмирането несъмнено е една от най-интересните области за професионална разработка на софтуер.

Обекти и класове

Основните блокове на обектно-ориентираната програма са обекти и класове. По отношение на съдържанието, един обект може да бъде представен като нещо усетено или въобразено и имащо добре дефинирано поведение. По този начин даден обект може или да бъде видян, докоснат или поне да се знае, че е там, например представен като информация, съхранена в компютърната памет. Нека дефинираме обект, като се придържаме към мнението на Гради Буча: „Обектът е осезаема единица, която ясно проявява своето поведение.“

Предмет -той е част от реалността около нас, т.е. съществува във времето и пространството (концепцията за обект в програмирането е въведена за първи път в езика Simula). Формално обектът е доста труден за дефиниране. Това може да стане чрез някои свойства, а именно: обектът има състояние, поведение и може да бъде уникално идентифициран (с други думи, има уникално име).

клас -това е набор от обекти, които имат обща структура и общо поведение. Класът е описание (абстракция), което показва как да се конструира променлива от този клас, която съществува във времето и пространството, наречена обект.Значението на изреченията „описание на класови променливи“ и „описание на класови обекти“ е едно и също.

Предметима състояние, поведение и паспорт (средство за еднозначната му идентификация); описват се структурата и поведението на обектите в класове,на които те са променливи.

Нека сега дефинираме понятията състояние, поведение и идентификацияобект.

Състояние на обектакомбинира всички свои полета с данни (статичен компонент, т.е. непроменлив) и текущите стойности на всяко от тези полета (динамичен компонент, т.е. обикновено променящ се).

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

Идентификация(разпознаване) на обект е свойство, което ви позволява да разграничите обект от други обекти от същия или други класове. Идентификацията се извършва чрез уникално име (паспорт), което се присвоява на обект в програмата, както всяка друга променлива.

Вече беше казано по-горе, че процедурният (както и модулният) подход ви позволява да създавате програми, състоящи се от набор от процедури (подпрограми), които изпълняват дадени алгоритми. От друга страна, обектно-ориентираният подход представя програмите като набор от обекти, които взаимодействат помежду си. Обектите взаимодействат чрез съобщения. Да приемем, че нашият обект е кръг. Тогава съобщението, изпратено до този обект, може да бъде: „нарисувай себе си“. Когато кажем, че е изпратено съобщение до обект, ние всъщност извикваме някои функциятози обект (функционален компонент). И така, в горния пример ще извикаме функция, която ще начертае кръг на екрана на дисплея.

Основни принципи на ООП

Основните принципи на стила на обектно-ориентираното програмиране включват:

• опаковане или капсулиране;
• наследство;
• полиморфизъм;
• предаване на съобщение.

Опаковка (капсулиране)

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

Обектът се характеризира като набор от всички негови свойства (например за животни - наличие на глава, уши, очи и т.н.) и техните текущи стойности (глава - голяма, уши - дълги, очи - жълти, и т.н.), както и набор от действия, приемливи за този обект (способността да се яде, седи, стои, бяга и т.н.). Тази комбинация в един обект на двете „материални“ съставни части (глава, уши, опашка, лапи) и действия, които манипулират тези части (действието „бягане“ бързо движи лапите) се нарича капсулиране.

В ООП данните се наричат ​​обектни полета, а алгоритмите се наричат ​​обектни методи.

Капсулирането ви позволява да изолирате обект от външната му среда до максималната възможна степен. Това значително повишава надеждността на разработените програми, т.к Алгоритмите, локализирани в даден обект, обменят относително малки количества данни с програмата и количеството и типът на тези данни обикновено се контролират внимателно. В резултат на това замяната или модифицирането на алгоритми и данни, капсулирани в даден обект, като правило не води до лошо проследими последствия за програмата като цяло. Друга важна последица от капсулирането е лекотата на обмен на обекти, прехвърлянето им от една програма в друга.

Наследство

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

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

Според Gradi Booch, "наследяването е връзка между обекти, в която един обект повтаря структурата и поведението на друг."

Принципът на наследствеността действа в живота навсякъде и всеки ден. Бозайниците и птиците наследяват характеристиките на живите организми; за разлика от растенията, орелът и гарванът наследяват общо свойство за птиците - способността да летят. От друга страна, лъвовете, тигрите, леопардите наследяват „устройството” и поведението, характерно за представителите на разред Felidae и др.

Типовете на горните нива на обектно-ориентирана йерархия обикновено нямат конкретни екземпляри на обекти. Няма, например, конкретен жив организъм, който сам по себе си да се нарича „бозайник“ или „птица“. Такива типове се наричат ​​абстрактни. Конкретните екземпляри на обекти, като правило, имат типове от най-ниските нива на OO йерархията: „Крокодилът Гена“ е специфичен екземпляр на обект от типа „крокодил“, „Котката Матроскин“ е специфичен екземпляр на обект от типа "котка".

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

Принципът на наследяването решава проблема с модифицирането на свойствата на даден обект и дава на ООП като цяло изключителна гъвкавост. Когато работи с обекти, програмистът обикновено избира обект, който е най-близък по своите свойства до решаването на конкретен проблем, и създава един или повече потомци от него, които „могат“ да правят това, което не е имплементирано в родителя.

Последователното прилагане на принципа „наследи и промени“ се вписва добре и силно насърчава постепенния подход към разработването на големи софтуерни проекти.

Когато създавате нов клас чрез наследяване от съществуващ клас, можете:

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

Полиморфизъм

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

Полиморфизмът е свойството на свързаните обекти (т.е. обекти, които имат един общ родител) да решават проблеми с подобно значение по различни начини. Например действието „бягане“ е обичайно за повечето животни. Всеки от тях обаче (лъв, слон, крокодил, костенурка) извършва това действие по различен начин.

С традиционен (необектно-ориентиран) подход към програмирането, програмистът ще премести животните, като извика отделна подпрограма за конкретно животно и конкретно действие.

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

Така в нашия пример с животински обекти действието „бягане“ ще се нарича полиморфно действие, а разнообразието от форми на проявление на това действие ще се нарича полиморфизъм.

Описание на типа обект

Клас или обект е структура от данни, която съдържа полета и методи. Като всяка структура от данни, тя започва със запазена дума и завършва с оператора край. Формалният синтаксис не е сложен: описание на тип обект се получава чрез замяна на думата в описанието на записа записна дума обектили класи добавете декларация на функции и процедури над полетата.

Тип<имя типа объекта>= обект
<поле>;
<поле>;
….
<метод>;
<метод>;
край ;

В ObjectPascal има специална запазена дума класза описание на обекти, заимстван от C++.

Тип<имя типа объекта>= клас
<поле>;
….
<метод>;
<метод>;
край ;

ObjectPascal поддържа и двата модела на описание на обекта.

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

Пример. Въвежда се тип обект "предшественик", който има поле с данни за име и може да извършва две действия:

• прокламирайте: „Аз съм прародител!“;
• дайте името си.

Тип tPredoc = име на обект: низ; (поле с данни за обект)
Процедурна декларация ; (декларация на обектни методи)
Процедура MyName ;
Край ;

Текстовете на подпрограмите, които реализират обектни методи, трябва да бъдат дадени в раздела, описващ процедурите и функциите. Заглавките при описание на реализацията на метода повтарят заглавките, дадени в описанието на типа, но се допълват от името на обекта, което е отделено от името на процедурата с точка. В нашия пример:

Процедура tPredoc.Declaration; (имплементация на обектен метод)
започвам
writeln("Аз съм прародител!");
край ;
Процедура tPredoc.MyName ; (имплементация на обектен метод)
започвам
writeln("Аз съм", Име);
край;

В описанията на методите полетата и методите от даден тип се споменават просто по име. Така че методът MyName използва полето Name, без да посочва изрично собствеността си върху обекта, сякаш неявният оператор with е изпълнен<переменная_типа_объект>направи.

Под обекти се разбират и променливи от обектен тип – те се наричат копия. Като всяка променлива, екземплярът има име и тип: те трябва да бъдат декларирани.

…….(декларация на тип обект и описание на неговите методи)
var v 1: tPredoc ; (декларация за екземпляр на обект)
започвам
v1. Име:= "Петров Николай Иванович";
v1.Декларация;
v1.MyName
край.

Използването на поле с данни на v1 обект е същият синтаксис като използването на полета за запис. Извикването на методи на екземпляр на обект означава, че посоченият метод се извиква с данните на обекта v 1. В резултат на това редовете ще бъдат показани на екрана

Аз съм прародител!
Аз съм Николай Иванович Петров

Подобно на записите, полетата на променливите тип обект могат да бъдат достъпни с помощта на квалифицирани идентификатори или оператор with.

Например в текста на програмата, вместо оператори

възможно е да се използва оператор with от този тип

с v1 направете
започвам
Име:= "Петров Николай Иванович";
Декларация ;
Моето име
Край ;

Освен това използването на израза with с типове обекти, както и за записи, е не само възможно, но и препоръчително.

Типова йерархия (наследяване)

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

Ако се въведе тип обект (предшественик, родител) и той трябва да бъде допълнен с полета или методи, тогава се въвежда нов тип, декларира се наследник (потомък, дъщерен тип) на първия и само нови полета и методи са описани. Потомъкът съдържа всички полета от типа предшественик. Имайте предвид, че полетата и методите на предшественика са достъпни за детето без специални инструкции. Ако описанието на наследника повтаря имената на полетата или методите на предшественика, тогава новите описания заменят полетата и методите на предшественика.

OOP винаги започва с базов клас. Това е шаблонът за основния обект. Следващата стъпка е да се дефинира нов клас, който се нарича производен клас и е разширение на базовия.

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

Производният клас не трябва да отменя всички методи на основния клас. Всеки нов обект наследява свойствата на базовия клас; трябва да дефинирате само онези методи, които са нови или са променени. Всички други методи на базовия клас се считат за част от производния клас. Това е удобно, защото... когато даден метод се промени в основния клас, той автоматично се променя във всички производни класове.

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

Най-често структурата на класовата йерархия се описва като дърво. Върховете на дървото съответстват на класове, а коренът съответства на клас, който описва нещо общо (най-често срещано) за всички останали класове.

Наследяването от дъщерни типове на информационни полета и методи на техните родителски типове се извършва съгласно следните правила.

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

Правило 2. Достъпът до полета и методи на родителски типове в рамките на дефиницията на всички дъщерни типове се извършва така, сякаш са описани в самия дъщерен тип.

Правило 3. Никой дъщерен тип не може да използва идентификаторите на полетата на своите родителски типове.

Правило 4. Дъщерен тип може да дефинира произволен брой свои собствени методи и информационни полета.

Правило 5. Всяка промяна на текста в родителски метод автоматично засяга всички методи на дъщерните типове, които го извикват.

Правило 6. За разлика от информационните полета, идентификаторите на методите в дъщерните типове могат да бъдат същите като имената на методите в родителските типове. В този случай се казва, че дъщерният метод замества (потиска) родителския метод със същото име. В рамките на дъщерен тип, когато се указва името на такъв метод, ще бъде извикан дъщерният метод, а не родителският.

Нека продължим с нашия пример. В допълнение към типа предшественик tPredoc, който въведохме, можем да въведем типове наследници:

ture tSon= object(tPredoc) (Тип, който наследява tPredoc)
процедура Декларация; (припокриващи се предходни методи)
процедура Моето име(Predoc: tPredoc);
край ;

Тип tGrandSon=object(tSon) (Тип, наследен от tSon)
процедура Декларация ; (припокриващи се предходни методи)
край ;

Името на типа предшественик е дадено в скоби след думата обект.Създадохме наследствена йерархия от три типа: tSon („син“) е наследник на типа tPredoc, а типът tGrandSon („внук“) е наследник на типа tSon. Типът tSon отменя методите Declaration и My Name, но наследява полето Name. Типът tGrandSon заменя само метода за декларация и наследява полето за име от неговия общ предшественик, а заменения метод за декларация от своя непосредствен предшественик (тип tSon).

Нека да разберем какво точно искаме да променим в родителските методи. Факт е, че „синът” трябва да провъзгласи малко по-различно от своя прародител, а именно да каже „Аз съм бащата!”

процедура tSon.Declaration; (имплементация на методи на наследствени обекти)
започвам
writeln("Аз съм бащата!");
край;

И когато дава името си, „синът“ трябва да предостави следната информация:

• аз<фамилия имя отчество >
• Аз съм синът<фамилия имя отчество своего предка>

процедура tSon .My Name (predoc: tPredoc);
започвам
наследени Mu Име; (извикване на метод на непосредствен предшественик)
writeln("Аз съм синът", predoc.Name, "a");
край;

В нашия пример наследникът tSon от метода My Name извиква метода със същото име на своя непосредствен предшественик тип tPredoc. Това повикване е предвидено от директивата наследени, последвано от извикването на метода на непосредствения предшественик. Ако има нужда да се извика метод на далечен предшественик в някакъв дъщерен тип на което и да е ниво на йерархията, тогава това може да се направи с помощта на квалифициран идентификатор, т.е. посочете изрично името на типа на родителския обект и, разделено с точка, името на неговия метод:

Сега да се заемем с "внука". Методът, в който "внукът" казва името си, е точно същият като неговия непосредствен предшественик (тип tSon), така че няма нужда да отменяте този метод, по-добре е автоматично да наследите този метод и да го използвате като свой собствен. Но в метода Декларация трябва да декларирате „Аз съм внук!“, така че методът ще трябва да бъде предефиниран.

процедура tGrandSon.Declaration;
започвам
writeln("Аз съм внук!");
край;

Нека разгледаме пример за програма, в която дефинираме екземпляр от типа tPredoc, наричаме го „дядо“, екземпляр от типа tSon „баща“ и екземпляр от типа tGrandSon „внук“. Нека ги помолим да се представят.

Примерна програма, използваща ООП

(заглавие на програмата)
……………….
(раздел с описания на типове, включително типове обекти tPredoc, tSon, tGrandSon)
(Забележка! Екземплярите на типове обекти могат да бъдат описани като въведени константи, което направихме по-долу за примера)
конст ded: tPredoc = (Име: "Николай Иванович Петров");
otec: tSon = (Име: "Петров Сергей Николаевич");
vnuk: tGrandSon = (Име: "Петров Олег Сергеевич");
(раздел с описания на процедури и функции, където трябва да бъдат написани всички методи, декларирани в типове обекти)
започвам
дед.Декларация; (извикване на методи с общ предшественик)
ded.Моето име;
writeln;
otec.Декларация;
otec.MyName(ded); (извикващи методи на otec обект от тип tSon)
writeln;
vnuk.Декларация; (извикващи методи на vnuk обект от тип tGrandSon)
vnuk.MyName(otec);
край.

Нашата програма ще покаже:

Пример за показване на резултата

Аз съм прародител!
Аз съм Николай Иванович Петров

Аз съм бащата!
Аз съм Петров Сергей Николаевич
Аз съм син на Петров Николай Иванович

Аз съм внук!
Аз съм Петров Олег Сергеевич
Аз съм син на Сергей Николаевич Петров

Моля, обърнете внимание, че в заглавката на процедурата tSon. MyName получава тип данни tPredoc като параметър и при използване на тази процедура му се предават променливи от двата типа tPredoc и tSon. Това е възможно, защото предшественикът е типово съвместим със своите потомци. Обратното не е вярно. Ако заменим tSon в заглавката на процедурата. MyName, когато описва параметри от тип tPredoc на tSon, компилаторът ще посочи несъвместимост на типа, когато използва променливата ded в реда otec. MyName(ded).

Полиморфизъм и виртуални методи

Полиморфизъм– това е свойството на свързаните обекти (т.е. обекти, които имат един и същ родител) да решават проблеми с подобно значение по различни начини.

Два или повече класа, които са извлечени от един и същ базов клас, се наричат ​​полиморфни. Това означава, че те могат да имат общи характеристики, но и да имат свои собствени свойства.

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

В примера, обсъден по-горе, и трите типа обекти tPredoc, tSon и tGrandSon имат едни и същи методи Declaration и MyName. Но обектният тип tSon имплементира метода MyName малко по-различно от своя предшественик. И трите метода за декларация с едно и също име се изпълняват по различен начин за всеки обект.

Обектните методи са статични, виртуални и динамични.

Статични методи

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

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

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

Виртуални методи

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

Този принципно нов механизъм, наречен късно свързване, осигурява полиморфизъм, т.е. различен начин на поведение за различни, но еднородни (в смисъл на наследяване) обекти.

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

процедура Метод (списък с параметри); виртуален;

Използването на виртуални методи в йерархията на типа обект има определени ограничения:

• ако даден метод е деклариран като виртуален, тогава в наследствен тип той не може да бъде заменен от статичен метод;
• обектите, които имат виртуални методи, се инициализират чрез специални процедури, които по същество също са виртуални и се наричат конструктор ;
• списъците с променливи и типове функции в заглавките на припокриващи се виртуални процедури и функции трябва да съвпадат напълно;

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

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

Конструкторът е специален метод, който инициализира обект, съдържащ виртуални методи. Заглавката на конструктора изглежда така:

Метод на конструктора (списък с параметри);

Запазена дума конструкторзамества думите процедура и виртуален .

Основната и специална цел на конструктора е да установява връзки с таблицата на виртуалните методи (VMT) - структура, съдържаща препратки към виртуални методи. По този начин конструкторът инициализира обекта чрез установяване на връзка между обекта и VMT с адресите на кодовете на виртуалния метод. По време на инициализация възниква късно свързване.

Всеки обект има своя собствена VMT виртуална таблица с методи. Това е, което позволява на метода със същото име да извиква различни процедури.

Като споменахме конструктора, трябва да кажем и за деструктор. Неговата роля е противоположна: извършване на действия, които завършват работата с обекта, затваряне на всички файлове, изчистване на динамична памет, изчистване на екрана и т.н.

Заглавката на деструктора изглежда така:

деструктор Готово;

Основната цел на деструкторите е да унищожат VMT на даден обект. Често деструкторът не прави нищо друго и е празна процедура.

деструктор Готово;
начало край;

Здравейте всички.

Седмица на статии в Habré, посветени на ООП. Последната статия ми предизвика много емоции и, за съжаление, много лоши емоции. Статията наистина не ми хареса. Защо? Защото предава някои негативни емоции относно използването на ООП. Емоциите са причинени само от факта, че човек не разбира напълно цялата сила на ООП и иска да убеди всички, че ООП е зло. Най-тъжното е, че хората започват да слушат и да изхвърлят ужасни аргументи, които нямат нищо общо с реалността. Смятам, че такива статии са по-противопоказни за студенти от GoF, които бих дал възможно най-рано. :)

Нека да започнем.

Какво е ООП? ООП е едновременно ООП програмиране и дизайн. Едното без другото е почти напълно безсмислено. Създаден OOP за проектиране/програмиране на софтуерни продукти. Не е за моделиране на процеси. Не за проектиране на протоколи, а специално за софтуерни продукти, за тяхното внедряване. За опростяване на система, която ще приложи протокол или бизнес процес или нещо друго.

Когато започнете да използвате ООП, първото нещо, което трябва да направите, е да започнете да използвате обектно мислене. Веднъж казах, че това е най-големият проблем на ООП; да се научиш да мислиш обективно е много трудно. И е много важно да се научите как да правите това възможно най-рано (GoF с аналогии като мост, конструктор, фасада ще помогне много за това). Използвайки обектно мислене, можете лесно да проектирате сложни системи. Използвайки обектно мислене, можете лесно да разрешите всеки проблем (много е важно всеки проблем при проектиране/програмиране, ако по принцип може да бъде решен абсолютно всеки), като работите с обекти и взаимодействието между тях. Тези. ООП без обектно мислене няма да ви позволи да започнете да използвате пълната мощ и сила на ООП.

Да отидем по-нататък. Така че за нас е важно да мислим обективно, за да намерим абстракциите на обектите, от които се нуждаем, за да решим проблемите си. Ако аналогиите и абстракциите са подбрани добре, тогава виждаме много ясна картина, която ни позволява бързо да разберем какво се случва в системата. И тук започваме да си спомняме за наследството и полиморфизма. Тези два инструмента са необходими за лесно мащабиране на системата без дублиране на код. Но силата на тези механизми зависи от това колко успешни са абстракциите и аналогиите, които избирате. Ако вашето обектно мислене не ви позволява да формирате удобна декомпозиция на обекти, тогава наследяването и полиморфизмът няма да ви помогнат. Тези. наследяването и полиморфизмът не са нищо повече от инструменти, които ви позволяват да разрешите проблема с мащабирането на системата.

Как работят тези инструменти? Да, по-просто е от задушената ряпа, защото всичко се основава на неща, които са ни познати. Обичам прости примери от живота:

1. Наследство. Има пекар. Има електрическа и газова фурна. Вашата задача е да симулирате процеса на готвене от пекар във всяка от пещите. Решавайки проблема директно, ще имаме много дублиране на кодове поради факта, че процесът на прехвърляне на храна във фурната и работата с фурните са идентични и за двете фурни. Но ако включим обектното мислене и си спомним за инструмента за наследяване, получаваме нещо като следното (твърде мързеливи, за да нарисуваме диаграма, съжалявам):
Има печка (абстрактна печка). Има поведение - включване, изключване, увеличаване или намаляване на температурата, поставяне на нещо, изваждане на нещо и състояние - температурата във фурната, включена или изключена. Това е отличен пример за абстрактен обект, който следва принципите на капсулиране (определено ще ги следвам при внедряването). И има един пекар, точно един пекар Иван. Той знае как да работи с абстрактна пещ. Тези. наблюдавайте температурата, включвайте и изключвайте и т.н. Разбра ли. Силата на наследството е, че не се налага да преписваме нашия Иван за всяка от печките, било то електрическа или газова. Мисля, че на всички е ясно защо? Оказва се, че инструментът е приложен правилно.
2. Полиморфизъм. Пещите работят по различен начин. Газовата печка консумира газ, електрическата печка консумира ток. Използвайки полиморфизма, можем лесно да променим поведението в наследниците на абстрактната пещ.
3. Капсулиране. Основното нещо при капсулирането е, че не е нужно да знам какво се случва във фурната ми. Да кажем, че не извиквам метода за включване на фурната, а променям свойството му enabled на true. Какво ще се случи в този момент? Ако не се спазва принципа на капсуловане, тогава ще бъда принуден да кажа на печката да започне да харчи гориво, защото... възбудих те. Тези. пекарят знае, че фурната харчи гориво и знае как работи фурната. Или, например, не можем да настроим температурата на фурната под или над определено ниво. Ако не спазваме принципа на капсулиране, тогава ще трябва да кажем на фурната да провери текущата температура, ще работи ли? Тези. Пекарят отново знае твърде много за фурната. Гетерите и сетерите са езикови инструменти, които ни помагат лесно да внедрим проследяване на промените в състоянието. Всичко. Ако гетерите и сетерите са празни, тогава това трябва да бъде на моето ниво на абстракция. Гетерите и сетерите не могат да се намесват в изпълнението на капсулирането; дизайнерът/програмистът може да приложи капсулирането криво.

В този пример нивото на абстракция е добре избрано. Всеки си гледа работата, и трите стълба на ООП работят за слава. Но щом избера лоши абстракции, започва истински кошмар. И дори има стандарти за контролни списъци, които ще ви помогнат да разберете дали сте избрали абстракциите добре и дали вашето разлагане е правилно в посоката, в която вървите (SOLID).

Те също започнаха да добавят абстракция като друг стълб на ООП. Мисля, че това вероятно е вярно, но наистина намирисва на CEP.

Твърденията за типизацията също привлякоха вниманието ми. Факт е, че няма проблеми с кой от наследниците работите в момента. Ако на сегашното ниво на абстракция за вас е важно да използвате фурната, тогава за вас няма значение какво е тя. Вземате ли печка? Решавате ли проблемите си? Това и онова... Защо смятате, че това е динамично писане не ми е ясно. Искахте ли да печете? Вземи го. Имате ли нужда от електрически? Е, съжалявам, бензинът вече няма да ви устройва.

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

Отделно за DTO. DTO е модел. Тя ви позволява да създадете обект, който ще прехвърли информация към друг слой, друга система, накратко, прехвърлете нещо някъде. Защо той не може да се разглежда от мен като обект, като цяло е мистерия за мен. Къде е противоречието? Само контейнер ли е? И какво?? Това е обект в рамките на обектния модел, който разгледах на дадено ниво на абстракция, където DTO е обект и част от декомпозицията.

Също така не е ясно какво да кажем за езиците. Мога да проектирам софтуер, използвайки обектно-базиран подход, независимо от езика. Но ако езикът не изпълнява основните инструменти за работа с обекти, тогава ще бъде много трудно или невъзможно за мен да внедря системата, която проектирах.

Те също така казват, че някои неща не могат да бъдат представени под формата на обекти и техните взаимодействия. Сигурен съм, че не е така. Просто трябва да изберете правилното ниво на абстракция. Независимо дали става въпрос за внедряване на протокол, слой за достъп до база данни, свързващи плъгини, мениджър на задачи, бизнес процес, система за проектиране на бизнес процеси и т.н. всичко може да бъде представено като обекти и техните взаимодействия. Всичко може да се реализира като обекти и взаимодействия между тях. Дали това е добро или лошо най-често зависи само от способността ви да мислите обективно.

Да обобщим. Ако не разбирате силата на ООП, тогава най-вероятно трябва да развиете обектно мислене.

P.S. В коментарите към последната статия явно прекалих, когато се обърнах към някои хора. Моите извинения.

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

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

Идеята за класовете е ядрото на обектно-ориентираното програмиране (ООП). Основните принципи на ООП бяха разработени още в езиците Simula-67 и SmallTalk, но по това време те не бяха широко използвани поради трудностите при изучаването и ниската ефективност на внедряването.

Извикват се специфични стойности на типа данни „клас“. екземпляри на класаили обекти (обекти) .

Извикват се подпрограми, които дефинират операции върху обекти на клас методи (методи). Извикват се извиквания на метод съобщения (съобщения). Целият набор от методи на обект се нарича протокол за съобщения или интерфейс за съобщения (съобщениеинтерфейс) обект. Съобщението трябва да има поне две части: конкретния обект, към който трябва да бъде изпратено, и името на метод, който указва необходимото действие върху обекта. По този начин изчислението в обектно-ориентирана програма се определя от съобщения, предавани от един обект на друг.

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

OOP е метод за програмиране, който развива принципите на структурираното програмиране и се основава на следните абстракции на данни:

аз Капсулиране : комбиниране на данни с процедури и функции в един блок програмен код (данните и методите за работа с тях се считат за обектни полета).

II. Наследство – прехвърляне на методи и свойства от предшественик към потомък, без необходимост от писане на допълнителен програмен код (наличие на екземпляри на клас; потомци, предци, йерархия).

III. Полиморфизъм – възможност за промяна на свойствата и поведението на обекти, които са идентични по значение в зависимост от техния тип (едно име за определено действие, което се извършва по различен начин за обекти от йерархията).

Капсулиране

Концепцията за капсулиране е използвана за първи път в езици, които поддържат така наречения абстрактен подход към програмирането (например Modula-2). Основната идея на абстрактния подход е да скрие структурата на информацията за даден обект от потребителя, като му дава възможност да получи данните, необходими за работа с обекта, само чрез процедури, свързани с този обект. Тази техника може значително да увеличи надеждността и преносимостта на разработения софтуер. Надеждността се увеличава поради факта, че всички процедури за работа с обектни данни са относително прости и прозрачни, което означава, че могат да бъдат разработени с по-добро качество. При промяна на структурата на данните е достатъчно да се преработят само програмите, пряко свързани с обекта, а по-сложните програми, които използват този обект, не трябва да се променят. Това обстоятелство повишава както надеждността, така и мобилността на създаваните програми.

Наследство

През втората половина на 80-те години на миналия век стана очевидно за много разработчици на софтуер, че една от най-добрите възможности за увеличаване на тяхната производителност е повторното използване на програми. Ясно е, че абстрактните типове данни, с тяхното капсулиране и контрол на достъпа, трябва да могат да се използват повторно. Проблемът с повторното използване на абстрактни типове данни в почти всички случаи е, че свойствата и възможностите на съществуващите типове не са подходящи за новата употреба. По-старите типове трябва да бъдат поне минимално модифицирани. Такива модификации могат да бъдат трудни за прилагане и изискват от човек да разбере част, ако не целия, от съществуващия код. Освен това в много случаи модификациите водят до промени във всички клиентски програми.

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

Наследяването решава както проблемите с модифицирането, които възникват от повторната употреба на абстрактен тип данни, така и проблемите с организацията на програмата. Ако нов абстрактен тип данни може да наследи данните и функционалните свойства на някакъв съществуващ тип, както и да модифицира някои от тези обекти и да добави нови обекти, тогава повторното използване е значително улеснено, без да е необходимо да се правят промени в повторно използвания абстрактен тип данни. Програмистите могат да вземат съществуващ абстрактен тип данни и да го моделират върху нов тип, който отговаря на новите изисквания на проблема. Да предположим, че вашата програма има абстрактен тип данни за масиви от цели числа, който включва операция за сортиране. След известен период на използване програмата се модифицира и изисква не само абстрактен тип данни за масиви от цели числа с операция за сортиране, но и операция за изчисляване на средно аритметично за елементи от обекти, които са масиви. Тъй като структурата на масива е скрита в абстрактен тип данни, без наследяване типът трябва да бъде модифициран чрез добавяне на нова операция към тази структура. При наследяването не е необходимо да се променя съществуващ тип; Възможно е да се опише подклас от съществуващ тип, който поддържа не само операция за сортиране, но и операция за изчисляване на средно аритметично.

Извиква се клас, който е дефиниран чрез наследяване от друг клас производен клас (получениклас) , или подклас (подклас) . Извиква се класът, от който е извлечен новият клас родителски клас (родителклас) , или суперклас (суперклас) .

В най-простия случай класът наследява всички обекти (променливи и методи) на родителския клас. Това наследяване може да стане по-сложно чрез въвеждане на контрол на достъпа до обектите на родителския клас.

Този контрол на достъпа позволява на програмиста да скрие части от абстрактния тип данни от клиентите. Този тип контрол на достъпа е често срещан в обектно-ориентирани езикови класове. Производните класове са друг вид клиент, на който може да бъде предоставен или отказан достъп. За да се приспособят към това, някои обектно-ориентирани езици включват трета категория контрол на достъпа, често наричана защитена, която се използва за предоставяне на достъп до производни класове и отказ на достъп до други класове.

В допълнение към наследените обекти, производният клас може да добавя нови обекти и да променя методи. Модифициран метод има същото име и често същия протокол като метода, на който е модификация. Твърди се, че новият метод замества наследената версия на метода, която следователно се нарича заменен метод. Най-общата цел на заместващия метод е да извърши операция, която е специфична за обекти от производния клас и не е специфична за обекти от родителския клас.

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

Недостатъкът на наследяването като средство за улесняване на повторната употреба на код е, че то създава зависимости между класовете в йерархията на наследяване. Това подкопава едно от предимствата на абстрактните типове данни, което е тяхната взаимна независимост. Разбира се, не всички абстрактни типове данни трябва да бъдат напълно независими, но като цяло независимостта на абстрактните типове данни е едно от най-силните им положителни свойства. Увеличаването на повторното използване на абстрактни типове данни, без да се създават зависимости между някои от тях, обаче може да бъде трудно, ако не и напълно безнадеждно.

Полиморфизъм

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

Изчисляване на обектно-ориентирани езици

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

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

Библиотека с визуални компоненти (VCL)

Делфисъдържа голям брой класове, предназначени за бързо разработване на приложения. Библиотеката е написана на Object Pascal и има директна връзка с интегрираната среда за разработка на приложения Delphi.

Всички VCL класове са разположени на определено ниво на йерархията и формата дърво (йерархия) от класове.

Познаването на произхода на даден обект е от голяма полза при изучаването му, тъй като детето наследява всички елементи на родителския обект. Така че, ако свойството Caption принадлежи към класа TControl, тогава неговите потомци също ще имат това свойство, например класовете TButton и TCheckBox и съответно компонентите Button и независимият ключ CheckBox. Фрагмент от йерархията на класовете с най-важните класове е показан на фиг.

В допълнение към йерархията на класовете голяма помощ при изучаването на системата за програмиране са изходните кодове на модулите, които се намират в директорията SOURCE на основната директория на Delphi.