Три принципа ооп: Объектно ориентированное программирование (C#)

Содержание

Объектно-ориентированное программирование для самых маленьких | by NOP | NOP::Nuances of Programming

Published in

5 min read

Jul 24, 2018

Перевод статьи Alexander Petkov: How to explain object-oriented programming concepts to a 6-year-old

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

Уверен, вы поняли, что я имею ввиду.

Ну вот, к примеру:

Кем вы видите себя через 5 лет?

Или еще «лучше»:

Какой ваш главный недостаток?

Боже, ответ на этот вопрос станет моим главным недостатком.

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

Отвечая на эти вопросы, вы должны быть очень осторожны, так как из-за невнимательность вы можете рассказать что-то такое, о чем позже пожалеете.

В сегодняшней статье я хочу разобрать похожий «клишированный» вопрос:

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

Я был по обе стороны стола, когда звучал этот вопрос. Он звучит настолько часто, что не знать ответа на него — просто невозможно.

В 90% случаев его задают новичкам, потому что он помогает разъяснить три вопроса:

Готовился ли кандидат к этому интервью?
Если ответ дается незамедлительно — кандидат ответственно подошел к делу.
Прошел ли кандидат начальный этап?
Понимание принципов объектно-ориентированного программирования (ООП) показывает, что кандидат прошел начальный этап — теперь он видит вещи с более продвинутой точки зрения.
Его понимание ООП находится на глубоком или поверхностном уровне?
Уровень компетентности по данному вопросу часто равен уровню компетентности по большинству других. Доверьтесь мне.

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

Для junior-разработчика слова могут показаться страшными и сложными. Вдобавок, при поиске ответа в Интернете, чрезмерно длинные объяснения в Википедии удваивают путаницу.

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

Допустим, у нас есть некая программа. У нее есть объекты, которые общаются между собой, в соответствии с правилами, установленными в программе.

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

Теперь допустим, что мы играем в Sims. У нас есть семья из нескольких людей и кошки. Они общаются друг с другом. Мы хотим применить инкапсуляцию, поэтому инкапсулируем всю логику «cat» в класс Cat. Это выглядит следующим образом:

Здесь внутренним состоянием кошки являются частные(private) переменные: настроение(mood), голод(hungry) и энергия(energy). Она также имеет частный(private) метод meow (). Кошка может вызвать его в любой момент, когда захочет, другие классы не могут говорить кошке, когда ей можно мяукать.

То, что им можно делать, определяется в публичных(public) методах sleep (), play () и feed (). Каждый из них каким-то образом влияет на внутреннее состояние кошки и может вызвать meow (). Таким образом, устанавливается связь между внутренним состоянием объекта и публичными методами.

Вот что такое инкапсуляция.

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

Абстракция нацелена на решение этой проблемы.

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

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

Данный механизм должен быть неприхотлив в использовании, а также редко меняться со временем. Подумайте об этом, как о наборе публичных(public) методов, которые любой другой класс может вызывать, не “зная”, как они работают.

Хотите еще один пример? Возьмите свой смартфон.

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

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

Наследование позволяет создать новый класс (производный класс) на основе уже существующего (родительский класс).

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

Например:

На данном примере, «обычный» преподаватель делится на «частного» и «публичного». «Частный» работает индивидуально с каждым студентом, а «публичный» со всеми в одно время. Эти классы имеют новые уникальные характеристики, не присущие родительскому классу.

На греческом, полиморфизм означает «многообразие форм».

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

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

Эту проблему можно решить, используя полиморфизм.

Полиморфизм позволяет использовать объекты с одинаковыми характеристиками в разных направлениях.

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

Данный принцип позволяет повысить коэффициент повторного использования кода.

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

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

Затем, если потребуется вычислить площадь какого-либо элемента, эта коллекция (список) найдет и выполнит правильный метод. Если элемент является треугольником, выполняется метод CalculateSurface (). Если это круг, выполняется метод CalculateSurface (). И так далее.

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

Надеюсь, мое «детское» объяснение вам помогло. Используйте его при прохождении собеседования и должность, фактически, вам обеспечена!

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

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

До скорых встреч!

Руководство C# | Основы объектно-ориентированного программирования

C# — Руководство по C# — Основы объектно-ориентированного программирования

Все основанные на объектах языки (C#, Java, С++, Smalltalk, Visual Basic и т.п.) должны отвечать трем основным принципам объектно-ориентированного программирования (ООП), которые перечислены ниже:

Инкапсуляция: Как данный язык скрывает детали внутренней реализации объектов и предохраняет целостность данных?
Наследование: Как данный язык стимулирует многократное использование кода?
Полиморфизм: Как данный язык позволяет трактовать связанные объекты сходным образом?

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

Роль инкапсуляции

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

Т.е. инкапсуляция представляет собой способности языка скрывать излишние детали реализации от пользователя объекта. Например, предположим, что используется класс по имени DatabaseReader, который имеет два главных метода: Open() и Close().

Фиктивный класс DatabaseReader инкапсулирует внутренние детали нахождения, загрузки, манипуляций и закрытия файла данных. Программистам нравится инкапсуляция, поскольку этот принцип ООП

упрощает кодирование.

Нет необходимости беспокоиться о многочисленных строках кода, которые работают «за кулисами», чтобы реализовать функционирование класса DatabaseReader. Все, что потребуется — это создать экземпляр и отправлять ему соответствующие сообщения (например, «открыть файл по имени AutoLot.mdf, расположенный на диске С:»).

С идеей инкапсуляции программной логики тесно связана идея защиты данных. В идеале данные состояния объекта должны быть специфицированы с использованием ключевого слова private (или, возможно, protected). Таким образом, внешний мир должен вежливо попросить, если захочет изменить или получить лежащее в основе значение. Это хороший принцип, поскольку общедоступные элементы данных можно легко повредить (даже нечаянно, а не преднамеренно).

Основной единицей инкапсуляции в C# является

класс, который определяет форму объекта. Он описывает данные, а также код, который будет ими оперировать. В C# описание класса служит для построения объектов, которые являются экземплярами класса.

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

Код и данные, составляющие вместе класс, называют членами. Данные, определяемые классом, называют полями, или переменными экземпляра. А код, оперирующий данными, содержится в функциях-членах, самым типичным представителем которых является метод. В C# метод служит в качестве аналога подпрограммы. (К числу других функций-членов относятся свойства, события и конструкторы.) Таким образом, методы класса содержат код, воздействующий на поля, определяемые этим классом.

Роль наследования

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

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

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

Роль полиморфизма

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

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

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

Рассмотрим для примера стек, т.е. область памяти, функционирующую по принципу «последним пришел — первым обслужен». Допустим, что в программе требуются три разных типа стеков: один — для целых значений, другой — для значений с плавающей точкой, третий — для символьных значений. В данном примере алгоритм, реализующий все эти стеки, остается неизменным, несмотря на то, что в них сохраняются разнотипные данные. В языке, не являющемся объектно-ориентированным, для этой цели пришлось бы создать три разных набора стековых подпрограмм с разными именами. Но благодаря полиморфизму для реализации всех трех типов стеков в C# достаточно создать лишь один общий набор подпрограмм. Зная, как пользоваться одним стеком, вы сумеете воспользоваться и остальными.

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

Ему достаточно запомнить и правильно использовать общий интерфейс.

Справочные материалы по C++ | Три столпа ООП

Справочный материал по C++ | Три столпа ООП

Три столпа объектно-ориентированного подхода Программирование

Каковы «три кита» объектно-ориентированного программирования (ООП)?

Обычно принято считать, что «тремя столпами» ООП являются:

Инкапсуляция
Наследство
Полиморфизм

Использование только инкапсуляции (т. е. определение и использование классов, но без использования наследования или полиморфизма) часто называют объектное программирование . Чтобы по-настоящему практиковать объектно-ориентированное программирование , вы должны использовать все три «столпы», то есть инкапсуляция, наследование, и полиморфизм.

Что такое инкапсуляция?

В C++ термин инкапсуляция относится к размещению обоих данные и операции в определении класса для реализации концептуальное понятие

абстрактного типа данных (ADT).

Тесно связаны понятия абстракции и сокрытие информации :

Термин абстракция относится к процессу извлечения «сущность» вещи или концепции реального мира и моделирование ее с помощью данные (абстракция данных) и операции (процедурная абстракция) АДТ. Часть данных этого дуэта обычно помещается в «частная» часть класса, в то время как операции образуют общедоступных интерфейс в ADT и поэтому помещаются в «общедоступные» часть определения класса.
Термин сокрытия информации относится к тому факту, что мы предотвратить доступ клиента класса к данным в реализация класса. Клиент не должен нуждаться в такой информации. Мы говорим, что практикуем
сокрытие информации путем определения наши занятия таким образом. Однако мы должны быть осторожны, чтобы не путать «недоступность» с «невидимостью», так как (по крайней мере, в случае C++) частная (данные) часть класса просто недоступный, не невидимый.

Что такое наследование?

В C++ есть две формы наследования , что также называется производным :

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

Следующая диаграмма UML (UML = унифицированный язык моделирования) иллюстрирует разницу, в общем, между одиночным и множественным наследство:

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

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

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

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

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

Чистая виртуальная функция — это функция, объявленная с следующий специальный синтаксис:

имя виртуального типа возврата (список_параметров) = 0;

Такая функция не имеет реализации в (абстрактном) классе. Это определяет что, но не как поведения объекта, и, по крайней мере, одна такая функция должна содержаться в классе, если этот класс должен быть абстрактный базовый класс.

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

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

Производный класс: [Optional_access_qualifier] Базовый
{
    //объявления
}

Квалификатор доступа для наследования может быть

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

Подводя итог, можно сказать, что ключевое слово доступа применяется к базовый класс указывает минимальную инкапсуляцию, которую производные члены get, с точки зрения производного класса [Josuttis].

Классификатор доступа по умолчанию является закрытым. Однако публичное наследование используется чаще всего, поэтому синтаксис обычно выглядит так: это:

Производный класс: общедоступная база
{
    ...
}

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

Если производный класс предоставляет новое определение для одного из членов функции своего базового класса, есть две возможности:

Во-первых, это случай, когда вы предоставляете точно такую же функцию подпись и возвращаемый тип в производном классе, как в базовом (или предок) класс. В этом случае функция на более высоком уровне говорят, что затенен тем, что находится на нижнем уровне, и это, в свою очередь, допускает еще две возможности:
- В случае обычной (т.е. не виртуальной) функции из класс более высокого уровня, он называется , переопределяя , который функция в производном классе более низкого уровня.
- В случае виртуальной функции из вышестоящего уровня класс, он называется , переопределяя эту функцию в производный класс более низкого уровня. Это обычный случай, основная причина почему мы сделали бы это в первую очередь, и случай, когда начинается полиморфизм.
Во-вторых, это случай, когда имя функции в производном class совпадает с именем функции в более высоком уровне class, но вы меняете либо список параметров, либо возвращаемый тип (или оба). В этом случае любые и все версии функции с это имя в классе более высокого уровня скрыто от просмотра в производный класс. Это действительно не должно быть сделано, потому что это означает, что вы, вероятно, используете класс иначе, чем способ, которым наследование предназначено для поддержки, и на самом деле у вас есть скомпрометировал «своего рода» характер наследования отношение. Другой способ сказать это, что вы не смогли соответствовать «принципу взаимозаменяемости».

Объект производного класса может быть присвоен переменной тип которого является базовым классом (или классом-предком), или скопировано в такую переменную, как это произошло бы при передаче производного возразите, например, параметру базового типа. Однако, любое из этих действий вызовет разрезание (т.е. так называемая проблема нарезки . Вот причина этого: в как правило, объект производного класса будет иметь больше элементов данных, чем его объекты базового или предкового класса, поэтому компилятор, не жалуясь, просто «отсекает» дополнительные элементы данных объекта производного класса и использует только члены, унаследованные от базового или предкового класса для переменная базового или предкового класса. Однако при ссылках или используются указатели на базовые аргументы, такой «нарезки» не происходит, что является одной из причин того, что ссылки и указатели так важно в объектно-ориентированном программировании на C++.

Что такое полиморфизм?

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

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

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

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

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

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

Специализация позволяет установить иерархические отношения между вашими классами. Например, вы можете определить Менеджера как специализированный тип Сотрудника и Служащий, чтобы быть специализированным типом Человека. Это позволяет вам максимально использовать состояние и возможности объекта Employee. специализированная форма менеджера.

Полиморфизм позволяет обрабатывать группу объектов сходным образом и пусть объекты разбираются, как реализовать программирование инструкции. Например, предположим, что у вас есть коллекция Employee объекты, и вы хотите сказать каждому сотруднику повысить себе зарплату. Получается, что Работники получают прибавку на 5 %, а надбавки за Менеджеры определяются тем, насколько хорошо они выполнили свои годовые задачи. С полиморфизмом вы можете сказать каждый объект в коллекции, чтобы дать себе повышение, и право происходит независимо от реального типа объекта. То есть, каждый сотрудник получает 5%, а каждый менеджер получает соответствующее повышение исходя из целей.

Инкапсуляция

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

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

Это достигается путем проведения яркой и блестящей линии между открытый интерфейс класса и его частная реализация . Публичный интерфейс есть контракт, выданный вашим классом, в котором говорится, что я обещаю быть в состоянии сделать эта работа. В частности, вы увидите, что интерфейс говорит, вызовите этот метод с этими параметрами и Я сделаю эту работу и верну это значение. Клиент может полагаться на то, что публичный интерфейс не изменится. Если публичный интерфейс изменяется, то клиент должен быть перекомпилирован и, возможно, переработан.

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

Например, у вас может быть общедоступный метод, который обещает следующее: Дайте мне сумму в долларах и количество лет, и Я верну чистую текущую стоимость. Как вы вычисляете эта сумма — ваше дело; если клиент предоставляет сумму в долларах и несколько лет, вы должны вернуть чистую текущую стоимость. Ты может реализовать это изначально, сохраняя таблицу значений. Ты может изменить это позже, чтобы вычислить значение, используя соответствующую алгебру. Это ваше дело и не влияет на клиент. Пока вы не меняете общественность интерфейс (например, пока вы не измените количество или тип ожидаемых параметров или изменить тип возвращаемое значение), ваши клиенты не сломаются, пока вы меняете выполнение.

Специализация и обобщение

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

Отношения специализации называются — это отношение. Собака — это млекопитающее , автомобиль — транспортное средство . (Собака будет производным от базового класса Mammal, Car от базового класса Транспортное средство.)

Специализация позволяет создавать семейство объектов. В Windows кнопка является элементом управления . Список — это элемент управления . Элементы управления имеют определенные характеристики (цвет, размер, расположение) и определенные способности (можно рисовать, можно выбран). Эти характеристики и способности наследуются всеми их производных типов. Это позволяет использовать очень мощную форму повторное использование. Вместо того, чтобы вырезать и вставлять код из одного типа в другой, общие поля и методы наследуются производным типом. Если вы меняете способ реализации общей способности, вам не нужно обновить код в каждом производном типе; они наследуют изменения.

Например, Менеджер — это особый тип Сотрудника. Менеджер добавляет новые возможности (наем, увольнение, вознаграждение, похвала) и новый состояние (годовые цели, уровень управления и т. д. ). Менеджер, однако также наследует характеристики и возможности, общие для все работники. Таким образом, у менеджера есть адрес, имя, идентификатор сотрудника, и Менеджеры могут быть повышены, могут быть уволены и так далее. Вы увидите специализацию в действии в главе 6.

Полиморфизм

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

Суть полиморфизма такова: временами вы будете знать, что у вас есть коллекция общего типа, например, коллекция элементов управления. Вы не знаете (или не заботитесь), какой конкретный подтип у каждого из ваших элементы управления (один может быть кнопкой, другой списком и т. д.). важно то, что вы знаете, что все они наследуют общие способности (например, метод Draw()) и что вы можете рассматривать их все как контролирует. Если вы напишете инструкцию по программированию, которая сообщает каждому элемент управления для рисования себя, это правильно реализовано для каждого элемента управления основе (т. е. кнопки отображаются как кнопки, списки рисуются как списки, и т. д.). Вам не нужно знать, как это достигается каждым подтипом; вам нужно только знать, что каждый тип определен, чтобы иметь возможность рисовать.

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

Получите курс Programming Visual Basic .NET, второе издание прямо сейчас с обучающей платформой O’Reilly.

члена O’Reilly знакомятся с книгами, живыми мероприятиями, курсами, подобранными в зависимости от должности, и многим другим от O’Reilly и почти 200 ведущих издателей.

Штирлиц — Сеть печатных салонов в Перми

Три принципа ооп: Объектно ориентированное программирование (C#) | Microsoft Learn