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

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

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

Обектът е колекция от свойства, методи, събития. Какво означава "съвкупност"? Това означава, че обектът, така да се каже, се състои от методи, свойства и събития и те осигуряват неговата пълноценна работа. Нека си представим един бутон. Тя притежава:

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

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

Свойстватаса променливи, които влияят на състоянието на даден обект. Например ширината и височината на даден обект.

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

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

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

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

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

1. Свойства:

• лява позицияНаляво;
• горна позицияНагоре;
• ширинаШирина;
• височинаВисочина;
• надписНадпис;

2. Методи:

• създайте бутон
• нарисувайте бутон
• бутон за унищожаване.

3. Събития:

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

Обектът работи като цяло. Например, променили сте надписа на бутон. Обектът генерира събитието „заглавието на бутона е променено“. При това събитие се извиква методът "бутон за рисуване". Този метод рисува бутона на позицията, посочена в свойствата на обекта, и показва новия текст на бутона, посочен в свойството "caption".

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

Сега помислете за използването на нашия бутон. Изглежда така:

1. Създаване на бутон чрез извикване на конструктор;
2. Промяна на необходимите свойства;
3. Всичко. Нашият бутон е готов за работа.

Обектът е сложен тип данни. Това означава, че можете да декларирате променливи от тип "обект" (точно както сте декларирали променливи от тип "число" или "низ") и да осъществявате достъп до обекта чрез тази променлива. На език за програмиране това би изглеждало малко по-сложно:

1. Декларирайте променлива от тип "бутон".
2. Инициализирайте обект в тази променлива.
3. Променете желаните свойства.
4. Можете да използвате обект.

Тук трябва да съберете всичко, което разбирате за обектите, в едно цяло. И така, можем да декларираме променливи от тип "обект". Нека декларираме обектна променлива от типButton. Сега можете да създадете бутон, за който има конструктор (метод за създаване на обект), който заделя свободна памет затози обект. Процесът на инициализация на обект бутон изглежда така: на променливатаObjectтрябва да бъде присвоен резултатът от операцията на конструктора на обектButton. Конструкторът ще разпредели паметта, необходима на обекта, и ще зададе свойствата на техните стойности по подразбиране. Резултатът от това действие ще бъде присвоен на променливатаObject. Тази променлива ще сочи към областта на паметта, в която се намира създаденият бутон, и неговите свойства. След всички тези действия можем да получим достъп до създадения обект чрез променливатаObject.

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

Старт на програмата

Променливи: Object1: Button; Начало на код Object1:= Button.Create object; Object1.Title:='Здравей'; Обект 1. Унищожете обекта. Край на кода;

Достъпът до свойствата и методите на обектите се осъществява с помощта на записа

Име на обект.Свойство или Име на обект.Метод

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

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

Неправилно използване на обект

Старт на програмата Променливи: Обект1: Бутон; Начало на код Object1.Header:='Hello'; Край на кода;

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

Обектът е много удобно нещо. Работи като шаблон, от който се създават променливи за тип обект. Например:

Шаблонен обект

Старт на програмата Променливи: Object1 — Бутон; Обект2 - Бутон; Начало на код Object1:= Button.Create object; Обект2:= Бутон.Създаване на обект; Object1.Title:='Здравей'; Object2.Title:='Чао'; Обект1.Унищожи обекта; Обект2.Унищожи обекта; Край на кода;

Инициализацията на обект също много често се нарича инстанциране на обект. И това също е правилно. Когато извикате конструктор, в паметта се създава нов екземпляр на обекта. В този пример можем да кажем, че нашите променливи object1 и Object2 сочат към техните собствени екземпляри на обекта Button, т.е. две независими копия на обекта (бутона) се получават в паметта. Всеки от тях може да бъде променен независимо и това няма да повлияе на другата променлива.

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

---