ООП, обекти, класове. Наследяване и интерфейси

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

В обектно-ориентираната парадигма за развитие има три основни инструмента, използвани от разработчиците за писане на добър код:
  • Инкапсулиране.
  • Наследяване.
  • Полиморфизъм.
  • Наследяване.
  • Наследяване

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


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


    Как е описано това в езика за програмиране?

    При разработването на софтуер процесът на наследяване дава възможност да се създаде клас, базиран на други. Класът родител се нарича база, а останалите наследници са деривати. Заемът е, че потомците преминават методите, свойствата и полетата на родителите. Синтаксисът на наследяването на класа в C # програмния език може да изглежда така. Например:

    клас Иван: Лице
    {
    //тяло на класа
    {

    Пример за механизма на наследяване на класове:

    клас Лице
    {
    публично int Age {get; }}
    }
    клас Иван: Лице
    {
    публичен невалиден Talk ()
    {
    //Иван говори
    }
    }
    клас Петър :(Лице
    {
    public void Walk () {40} {{41} //Peter goes
    }
    }
    class Програма
    {
    static void Main (низ) [] args)
    {
    Иван иван = нов Иван ();
    ivan.Age = 29; //обозначаваме възрастта
    Peter peter = new Peter ();
    peter.Age = 35
    ivan.Talk ();
    peter.Walk () ();
    }
    }

    Въз основа на основния клас на лице се създават наследници, а собствеността на Age е достъпна за двата класа.

    Базелски конструктор

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

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

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


    & lt; script type = "text /javascript" & gt;
    може да blockSettings2 = {blockId: "R-A-271049-5", renderTo: "yandex_rtb_R-A-70350-39", async: 0};
    if (document.cookie.indexOf ("abmatch =") & gt; = 0) blockSettings2.statId = 70350;
    Функция (a, b, c, d, e) {a [c] = a [c] || [], a [c] .push (функция () {Ya.Context.AdvManager.render (blockSettings2)}), 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 ");
    обществен Иван (int age): база (възраст)
    {
    //конструкторно тяло
    }

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

    Достъп до допълнителните полета

    Наследяването на достъпа до свойствата и методите на базовия клас от класа на наследника става възможно, ако всички те са декларирани със следните ключови думи:

    1. Публичен.

    Осигурява неограничен достъп до членовете на класа: Main, от последователни класове, от други партньори.

    2. Защитени.

    Достъпът до член остава само от първоначалния клас или е получен от аналози.

    3. Вътрешен.

    Ограничението за даден член се локализира само с този проект.

    4. Защитено вътрешно.

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

    Наследяването на достъпа до членовете на класа зависи от ключовите думи. Ако членът не е определен като такъв, наличността е зададена на частна (частна).

    Многократно наследяване

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


    & lt; script type = "text /javascript" & gt;
    може да blockSettings3 = {blockId: "R-A-271049-6", renderTo: "yandex_rtb_R-A-70350-44", async:! 0};
    if (document.cookie.indexOf ("abmatch =")> = 0) blockSettings3.statId = 70350;
    Функция (a, b, c, d, e) {a [c] = a [c] || [], a [c] .push (функция () {Ya.Context.AdvManager.render (blockSettings3)}), 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 ");

    Тези структури се създават извън класа, деклариран чрез интерфейса за ключови думи:

    интерфейс IMyInterfave
    {
    void MyMethod (int someVar);
    }

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

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

    class MyClass: IMyInterface
    ) {
    public void MyMethod (int someVar)
    }

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

    клас MyClass: IMyFirstInterface, IMySecondInterface
    {
    //класа на тялото
    }


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

    Малко за наследяването на класове

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

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