OOP класове. Обектно-ориентирано програмиране

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

Какво е ООП (обектно-ориентирано програмиране)

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


Съвременните езици за програмиране Delphi, Java, C # и други следват обектно-ориентиран подход. В същото време се дава значението на данните, а не само да се пишат инструкции за задачата. Един обект е нещо или идея, която искате да симулирате. Те могат да бъдат всичко, например служител, банкова сметка, кола, различни позиции от ситуацията и т.н. Понятието обектно-ориентирано програмиране (ООП) е неразривно свързано със следните критерии:
  • Абстракция.
  • Инкапсулиране.
  • Наследяване.
  • Полиморфизъм. Разгледайте всеки един от тях по-подробно.

    Абстракция

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


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

    Инкапсулиране

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

    Наследяване

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

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

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

    Характеристики на понятията "клас" и "обект"

    За да започнем работа с обектно-ориентирано програмиране, трябва да разберем какво е клас на ООП и обект. Важно е да се разбере разликата между тях. Класът е план засъздаване на обект. Той определя атрибутите и поведението. Прилича на инженерна рисунка на къщата. Обектът е инстанция на класа. Ето разликата между тях. Следният пример показва как класът TForml и Forml са декларирани в езика за програмиране на Delphi:



    тип
    TForml = class (TForm)
    Buttonl: TButton;
    процедура ButtonlClick (подател: TObject);
    край;
    може
    Forml: TForml;

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

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

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

    Метод на спиране: прекъсване ()
    Обект 1 Обект 2
    модел: Vaz 2107 модел: Vaz 2109
    гориво: бензин гориво: дизел
    цвят: червен цвят: зелен
    метод за стартиране на двигателя: Старт () метод за стартиране на двигателя: Старт()
    метод на спиране: прекъсване ()
    Метод на ускоряване: ускорение () Метод на ускорение: ускорение ()
    По този начин обектно-ориентираното програмиране улеснява симулирането на поведението на сложна реална система. От ООП данни и функции (атрибути и методи) се комбинират в обект. Това предотвратява необходимостта от общи или глобални данни за ООП. Този подход е основната разлика между обектно-ориентираните и процедурните подходи.

    Класовете на ООП се състоят от елементи от различни типове:

    1. Полета с данни: съхранява състоянието на класа чрез променливи и структури.
    2. Методи: подпрограми за манипулиране на посочените данни.
    3. Някои езици позволяват на третия тип собственост да бъде. Това е нещо между първите две.

    Методи

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


    & lt; script type = "text /javascript" & gt;
    може да blockSettings = {blockId: "R-A-70350-45", renderTo: "yandex_rtb_R-A-70350-45", async:! 0};
    if (document.cookie.indexOf ("abmatch =")> = 0) blockSettings.statId = 70350;
    Функция (a, b, c, d, e) {a [c] = a [c] || [], a [c] .push (функция () {Ya.Context.AdvManager.render (blockSettings}), e = b.getElementsByTagName ("скрипт") , d = b.createElement ("скрипт"), d.type = "text /javascript", d.src = "//an.yandex .ru /system /context.js ", d.async =! 0e.parentNode.insertBefore (d, e)} (това, този.документ," yandexContextAsyncCallbacks ");

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

    Интерфейс

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

    Един обект може да има няколко роли и потребителите могат да го използват от различни гледни точки. Например, обект от типа "човек" може да има роля:

    • Войник (с поведението на "стреляй по врага").
    • Човек (с поведението на "обича жена си").
    • Данъкоплатец (с поведението на "плащат данъци") и т.н.
    Все пак всеки обект осъзнава поведението си по свой собствен начин: Миша плаща данъци навреме, Андрей със закъснение, а Петър изобщо не го прави. Същото може да се каже за всеки обект и други роли.

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

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

    Designer

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

    Следният пример обяснява концепцията за конструктор на клас в C ++ (общ език за програмиране):

    # включва
    използвайки пространство от имена std;

    клас Линия {
    публична:
    невалидна setLength (двойна лента);
    двойно getLength (void);
    Линия (); //Дизайнерска декларация
    частна: двойна дължина;
    };

    //Дефиниция на функции, включително конструктор

    Line :: Line (void) {
    cout "Object created" endl;
    }

    void Line :: setLength (double len) {
    дължина = дължина;
    }

    двойна Line :: getLength (void) {
    връщана дължина;
    }

    //Тялото на програмата

    int main () {
    Линия;

    //Дължина на линия

    line.setLength (6.0);
    cout "Дължина на реда:" line.getLength () endl;
    връщане 0;
    }

    Когато горният код се компилира и изпълни, той дава следния резултат:

    Създаден обект

    Дължина на ред: 6

    Destructor

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

    Синтаксисът за деструктора е същият като за конструктора, но името на класа се използва в този случай с по-малкия знак "~" като префикс.

    Следният пример в C ++ обяснява концепцията за деструктор:

    # включва
    използвайки пространство от имена std;

    клас Линия {
    публичен: void setLength (double len);
    double getLength (void);
    ред (); //Дизайнерски анотации
    ~ Line (); //Съобщение на разрушителя
    частно: двойна дължина;
    }

    //Дефиниция на функции, включително конструктор

    Line :: Line (void) {
    cout "Object created" endl;
    }

    Line :: ~ Line (void) {
    cout "Обектът е отдалечен" endl;
    }

    void Line :: setLength (double len) {
    дължина = len;
    }

    double Line :: getLength (void) {
    връщане на дължината;
    }

    //Тяло на програмата

    int main () {
    Линия;

    //Дължина на линия

    line.setLength (6.0);
    cout "Дължина на реда:" line.getLength () endl;
    връщане 0;

    }

    Когато горният код се компилира и изпълни, той дава следния резултат:

    Създаден обект

    Дължина на реда: 6

    Обектът е отдалечен

    Какви са предимствата на класовете

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

    Свързани публикации