Лекция
Сразу хочу сказать, что здесь никакой воды про наследование, и только нужная информация. Для того чтобы лучше понимать что такое наследование, полиморфизм, внутренние классы, вложенные классы, локальные классы, дружественные классы, дружественные функции , настоятельно рекомендую прочитать все из категории Объектно-ориентированное программирование ООП.
наследование и полиморфизм - это два ключевых концепта объектно-ориентированного программирования (ООП).
Наследование позволяет создавать новые классы, которые наследуют свойства и методы существующих классов (родительских классов), тем самым расширяя их функциональность. Дочерний класс может использовать свойства и методы родительского класса, а также добавлять свои собственные свойства и методы.
Полиморфизм позволяет использовать один и тот же метод с разными классами, производными от одного и того же базового класса, не заботясь о типе объекта. Это значит, что разные классы могут иметь методы с одинаковым именем, но разной реализацией.
Пример наследования и полиморфизма в ООП:
У нас есть базовый класс "Фигура", который содержит методы для вычисления площади и периметра. От него наследуются классы "Круг", "Квадрат" и "Прямоугольник". Каждый из этих классов реализует свой собственный метод для вычисления площади и периметра. Например, метод вычисления площади для круга принимает радиус, для квадрата - длину стороны, а для прямоугольника - длину и ширину.
Когда мы вызываем метод для вычисления площади для каждой из этих фигур, мы можем использовать один и тот же метод, не заботясь о том, какой тип фигуры мы передаем в качестве параметра. Это называется полиморфизмом.
Наследование - один из четырех главных механизмов объектно-ориентированное программирование (с учетом инкапсуляции, полиморфизмом и абстракцией), способно описать новый класс, на основе уже существующего (родительского), с таким свойствами и функциональностью родительского класса, замещаются новым классом.
Класс-наследник реализует спецификацию уже существующего класса (базовый класс). Это возможно обратитися с объектами класса-наследника точно так же, как и с предметами базового класса.
Простое наследование:
Класс, от которого производится наследование, называется базовым или родительским (англ. Базовый класс). Классы, которые выдавали с базового, называют потомками, наследниками или производными классами (англ. Походный класс).
В некоторых языках используются абстрактные классы. Абстрактный класс - это класс, содержит Хоту по одному абстрактным методом, он описывается в программе, имеет поля, методы и не может быть использован для прямого создания объекта. Существует от абстрактного класса можно только Наследова. Объекты создаются только на основе производственных классов, наследованих от абстрактного. Например, абстрактным классом может быть базовый класс «сотрудник вузы», от которого следуют классы «аспирант», «профессор» и т. Д. Так как производственные классы имеют общие поля и функции (например, поле «год рожд»), поэтому эти члены класса могут быть описаны в базовом классе. В программе создаются объекты на основе класса «аспирант», «профессор», но не существует создания созданных объектов на основе класса «сотрудник вузы».
Множественное наследование
При множественном наследовании в классе может быть больше одного предка. В этом случае класс наследует методы всех предков. Достоинство такого подхода в большей гибкости. Многолетнее подражания реализовано в C ++. Некоторые другие языки тоже поддерживают это, такие как Python и Eiffel . Множественное наследование поддерживается в языке UML.
Множественное наследование - потенциальный источник ошибок, которые могут подняться из-за наличия одинаковых именных методов в предках. В языках, которые позиционируют как наследники C ++ (Java, C # и др.), От многих других наследий было решено отказаться от использования интерфейсов. Практически всегда можно обойтись без использования данного механизма. Однако, если таковая необходима, то все-таки возможно, чтобы решить конфликты, используя наследовани методы с одинаковыми именами быть, например, заменить операцию расширения видимости - «::» - для вывода конкретного метода конкретного родителя.
Попытка решения проблем имеющихся одинаковых именных методов в предыдущих была подготовлена на языке Эйфель, в котором в описании нового класса нужно явно войти импортруваних членов каждого из наследуваних классов и их имени в дочерних классе.
Большинство современных объектно-ориентированных языковых программ (C #, Java, Delphi и др.) Поддерживают возможность одновременно наследоваться от класса-предка и реализовать методы неоднократных интерфейсов одних и темных классов. Этот механизм способен во многих изменениях множественного наследования - методов интерфейсов, необходимых переопределить явно, что исключает ошибки при наследовании функциональных одинаковых методов различных классов-предков.
Закрытое наследование - это когда спецификатор доступа принимает значение private, при этом все публичные и защищенные члены базового класса становятся частными членами производного класса. Закрытое наследование означает реализацию посредством - т.е. от базового класса необходимо взять какую-то функциональность, базовый класс и потомок не имеют како-либо концептуальной связи.Закрытое наследование не носит характера отношения подтипов.Закрытое (также как и защищенное) наследование не создает иерархии типов.
Есть несколько сценариев, когда стоит применять закрытое наследование вместо агрегации:
Если все это нужно, то закрытое наследование будет более предпочтительным агрегации.
Агрегация или включение – это когда членом одного класса становится объект другого:
Пример использования включения:
Пусть класс D имеет член класса B.
В свою очередь класс B имеет член класса C.
Таким образом, используя включение мы строим иерархию объектов. С точки зрения проектирования закрытое наследование равносильно включению, если не считать вопроса с замещением функци
В общем случае между включением и наследованием(не закрытым) есть принципиальная разница:
Включение — это отношение has a (имеет).Используя включение мы строим иерархию объектов.
Наследование — это отношение is a (является). Используя наследование (не закрытое), мы сторим иерархию классов.
Пример: автомобиль имеет руль, колеса и т.д. и т.п.
И автомобиль является транспортным средством.
Есть несколько сценариев, когда стоит применять закрытое наследование вместо включения:
Необходимо переопределение абстрактных и/или виртуальных методов.
Необходимо использовать экземпляр наследника полиморфным образом в ограниченном окружении (например, в дружественной функции). Но в общем смысле отношение ЯВЛЯЕТСЯ между наследником и базовым классом отсутствует.
При закрытом наследовании, наследник может обращаться к защищенным членом базового класса.
Закрытое наследование позволяет реализовать "сужающее" наследование. Когда наследник содержит лишь несколько методов базового класса (путем поднятия видимости с помощью using Base::ProtectedMethod).
Если все это нужно, то закрытое наследование будет более предпочтительнее включения.
Полиморфизм - возможность объектов с одинаковой спецификацией иметь различную реализацию.
Язык программной поддержки поддерживает полиморфизм, если класс с одинаковой спецификацией могут иметь различную реализацию - например, реализация класса может быть изменена в процессе работы .
Краткое содержание полиморфизма можно выразить фразой: «Один интерфейс, большая реализация».
Полиморфизм - один из четвертых важных механизмов объектно-ориентированное программное обеспечение (с абстракцией, инкапсуляцией и наследованного).
Полиморфизм позволяет писать более абстрактные программы и увеличивать кофефициент повторного использования кода. Об этом говорит сайт https://intellect.icu . Общие свойства объектов объединяются в системе, которую можно назвать по-разному - интерфейс, класс.
Определение имеет внешнее и внутреннее выражение:
внешняя общность проявляется как одинаковый набор методов с одинаковыми именами и сигналами (именометрии и типы аргументов и их количество);
внутренняя общность - одинакова функциональность методов. Можно описать интуитивное или выразить в суровых законах, правилах, которые должны обязательно подписать методы. Функция функционирование одного метода (функции, операции) называет перегрузкой метода (перегрузкой функций, перегрузка операций).
Используя параметрический полиморфизм можно создать универсальные базовые типы. В случае параметрического полиморфизма функция реализуется для всех типичных одинаковых и таких функций, реализуемых для производственного типа. В параметрическом полиморфизме рассматриваются параметрические методы и типы.
Параметрические типы.
Вместо того, чтобы писать класс для каждого конкретного типа следует создать типы, которые будут реализованы во время выполнения программы то есть мы создаем параметрический тип.
Абстрактные методы часто относятся к отложенным методам. Класс, в котором определен этот метод может вызвать метод и полиморфизм обеспечивает вызов подходящей версии отложенного метода в дочерних классах. Специальный полиморфизм допускает специальную реализацию для данных каждого типа.
Полиморфизм-перегрузка - это частный случай полиморфизма.
class Shape:
def area(self):
pass
def perimeter(self):
pass
class Circle(Shape):
def __init__(self, radius):
self.radius = radius
def area(self):
return 3.14 * self.radius * self.radius
def perimeter(self):
return 2 * 3.14 * self.radius
class Square(Shape):
def __init__(self, side):
self.side = side
def area(self):
return self.side * self.side
def perimeter(self):
return 4 * self.side
class Rectangle(Shape):
def __init__(self, length, width):
self.length = length
self.width = width
def area(self):
return self.length * self.width
def perimeter(self):
return 2 * (self.length + self.width)
shapes = [Circle(5), Square(10), Rectangle(3, 4)]
for shape in shapes:
print("Area: ", shape.area())
print("Perimeter: ", shape.perimeter())
Таким образом
Оба этих принципа являются важными концепциями ООП и позволяют создавать более гибкие и масштабируемые программные системы, облегчая повторное использование кода и уменьшая объем написанного кода.
Внутренний, или вложенный класс (англ. inner class) — в объектно-ориентированном программировании класс, целиком определенный внутри другого класса.
вложенные классы поддерживаются в языке программирования Java, начиная с версии 1.1, С# и других языках на платформе .NET, а также в языке программирования D и в C++.
Экземпляр обычного (внешнего) класса может существовать как независимый объект. Для его существования не требуется обязательное наличие определений других классов или их экземпляров. В случае внутреннего класса, его экземпляр не может существовать без привязки к включающему его классу верхнего уровня либо его экземпляру.
В Java существуют 4 типа внутренних (inner) классов:
Экземпляр внутреннего класса может существовать только тогда, когда существует конкретный экземпляр внешнего класса. Такая логическая связь обусловливает синтаксис создания объектов: сначала создается объект внешнего класса, позднее на его основе создается объект внутреннего класса.
Внутренние нестатические классы описываются внутри основного внешнего класса. Экземпляры таких классов имеют доступ к public, protected, default и private полям внешнего класса. А также статическим и нестатическим методам внешнего экземпляра с любыми модификаторами доступа. За счет того, что экземпляры внутреннего класса всегда логически привязаны к экземплярам окружающего класса, они не могут содержать (хотя могут наследовать от предка) определение статических полей, методов и классов (кроме констант).
Пример объявления внутреннего класса:
Создание описанного класса можно описать следующим блоком кода: OuterClass.InnerClass inner = new OuterClass().new InnerClass();
Декларируются внутри основного класса и обозначаются ключевым словом static. Объекты таких классов не имеют доступа к членам внешнего класса за исключением статических. Это обусловлено тем, что для создания такого класса не используется конкретный объект внешнего класса и в момент исполнения кода внутреннего класса, объекта внешнего может вовсе не быть. Экземпляры статических вложенных классов могут содержать статические поля, методы и классы, в отличие от других типов внутренних классов.
Пример объявления вложенного статического класса:
Создание описанного статического вложенного класса можно описать следующим блоком кода: OuterClass.StaticInnerClass staticInner = new OuterClass.StaticInnerClass();
Декларируются внутри методов основного класса. Могут быть использованы только внутри этих методов. Имеют доступ к членам внешнего класса. Имеют доступ как к локальным переменным, так и к параметрам метода при одном условии - переменные и параметры, используемые локальным классом, должны быть задекларированы final. Не могут содержать определение (но могут наследовать) статических полей, методов и классов (кроме констант).
Пример:
Создание описанного локального класса возможно только внутри самого метода строго ниже кода объявления самого класса. Пример кода создания: InnerLocalClass innerLocal = new InnerLocalClass();
Декларируются внутри методов основного класса. Могут быть использованы только внутри этих методов. В отличие от локальных классов, анонимные классы не имеют названия. Главное требование к анонимному классу - он должен наследовать существующий класс или реализовывать существующий интерфейс. Не могут содержать определение (но могут наследовать) статических полей, методов и классов (кроме констант). Пример:
В PHP 7 есть механизм описания анонимных классов, однако, в отличие от Java, анонимные классы не обязаны наследовать существующий класс или реализовывать существующий интерфейс, что достигается благодаря динамической природе языка. Пример:
Таким образом мы рассмотрели достоинства сохранения скрытости данных, но иногда вы можете столкнуться с ситуациями, когда обнаружите, что у вас есть классы и функции вне этих классов, которые должны очень тесно работать друг с другом. Например, у вас может быть класс, в котором хранятся данные, и функция (или другой класс), которая отображает эти данные на экране. Хотя класс хранилища и код отображения были разделены для упрощения поддержки, код отображения на самом деле тесно связан с деталями класса хранилища. Следовательно, скрытие сведений о классах хранения от кода отображения не дает особой выгоды.
В подобных случаях есть два варианта:
Дружественная функция – это функция, которая может получить доступ к закрытым членам класса, как если бы она была членом этого класса. Во всем остальном дружественная функция похожа на обычную функцию. Дружественная функция может быть либо обычной функцией, либо функцией-членом другого класса. Чтобы объявить дружественную функцию, просто используйте ключевое слово friend перед прототипом функции, которую вы хотите сделать другом класса. Не имеет значения, объявляете ли вы дружественную функцию в закрытом или открытом разделе класса.
Вот пример использования дружественной функции:
В этом примере мы сделали функцию с именем reset(), которая принимает объект класса Accumulator и устанавливает значение m_value равным 0. Поскольку reset() не является членом класса Accumulator, обычно reset() не будет иметь доступ к закрытым членам Accumulator. Однако, поскольку Accumulator специально объявил эту функцию reset() как друга класса, то ей предоставляется доступ к закрытым членам Accumulator.
Обратите внимание, что мы должны передать в reset() объект Accumulator. Это потому, что reset() не является функцией-членом. У нее нет указателя *this и нет объекта Accumulator для работы, если он не указан.
Вот еще один пример:
В этом примере мы декларируем функцию isEqual() другом класса Value. isEqual() принимает в качестве параметров два объекта Value. Поскольку isEqual() является другом класса Value, она может получить доступ к закрытым членам всех объектов Value. В этом случае она использует этот доступ для сравнения двух объектов и возвращает true, если они равны.
Хотя оба приведенных выше примера довольно надуманы, последний пример очень похож на случаи, с которыми мы столкнемся позже, когда будем обсуждать перегрузку операторов!
Функция может быть другом для более чем одного класса одновременно. Например, рассмотрим следующий пример:
В этом примере стоит отметить две вещи. Во-первых, поскольку printWeather является другом обоих классов, она может получить доступ к закрытым данным из объектов обоих классов. Во-вторых, обратите внимание на следующую строку в верхней части примера:
class Humidity;
Это прототип класса, который сообщает компилятору, что в будущем мы собираемся определить класс под названием Humidity. Без этой строки компилятор при синтаксическом анализе прототипа для printWeather() внутри класса Temperature сообщил бы нам, что не знает, что такое Humidity. Прототипы классов выполняют ту же роль, что и прототипы функций – они сообщают компилятору, как что-то выглядит, чтобы его можно было использовать сейчас и определить позже. Однако, в отличие от функций, классы не имеют возвращаемых типов или параметров, поэтому прототипы классов всегда представляют собой просто class ClassName, где ClassName – это имя класса.
Также целый класс можно сделать другом другого класса. Это дает всем членам дружественного класса доступ к закрытым членам другого класса. Вот пример:
Поскольку класс Display является другом Storage, любой из членов Display, использующих объект класса Storage, может напрямую обращаться к закрытым членам Storage. Эта программа дает следующий результат:
6.7 5
Несколько дополнительных замечаний о дружественных классах.
Во-первых, даже несмотря на то, что Display является другом Storage, Display не имеет прямого доступа к указателю *this объектов Storage.
Во-вторых, то, что Display является другом Storage, не означает, что Storage также является другом Display. Если вам нужно , чтобы два класса дружили друг с другом, они оба должны объявить друг друга друзьями. Наконец, если класс A является другом B, а B – другом C, это не означает, что A является другом C.
Будьте осторожны при использовании дружественных функций и классов, потому что это позволяет дружественной функции или классу нарушать инкапсуляцию. Если детали реализации класса изменятся, то детали реализации друга также должны будут быть изменены. Следовательно, ограничьте использование дружественных функций и классов до минимума.
Вместо того чтобы делать другом весь класс, вы можете сделать другом только одну функцию-член. Это выполняется так же, как сделать дружественной обычную функцию, за исключением использования имени функции-члена с включенным префиксом ИмяКласса:: (например, Display::displayItem).
Однако на самом деле это может быть немного сложнее, чем ожидалось. Давайте, преобразуем предыдущий пример, чтобы сделать Display::displayItem дружественной функцией-членом. Вы можете попробовать сделать что-то вроде этого:
Однако оказывается, что это не будет ботать. Чтобы сделать функцию-член другом, компилятор должен увидеть полное определение класса функции-члена (а не только предварительное объявление). Поскольку класс Storage еще не видел полного определения класса Display, компилятор выдаст ошибку в тот момент, когда мы попытаемся сделать функцию-член другом.
К счастью, это легко решить, просто поставив определение класса Display перед определением класса Storage.
Однако теперь у нас есть инаяпроблема. Так как функция-член Display::displayItem() использует Storage в качестве ссылочного параметра, а мы только что переместили определение Storage ниже определения Display, компилятор будет жаловаться, что не знает, что такое Storage. Мы не можем исправить это, изменив порядок определения, потому что тогда мы отменим предыдущее исправление.
К счастью, это тоже можно исправить, выполнив пару простых шагов.
Во-первых, мы можем добавить класс Storage в качестве предварительного объявления.
Во-вторых, мы можем переместить определение Display::displayItem() из класса на место после полного определения класса Storage.
Вот как это выглядит:
Теперь все будет скомпилировано верно: предварительного объявления класса Storage достаточно, чтобы удовлетворить объявление Display::displayItem(), полное определение Display удовлетворяет объявлению Display::displayItem() как друга Storage, а полное определение класса Storage достаточно, чтобы удовлетворить определение функции-члена Display::displayItem(). Если это немного сбивает с толку, смотрите комментарии в программе.
Если это похоже на сложность– это так. К счастью, эта хитрость необхода только потому, что мы пытаемся сделать все в одном файле. Лучшее решение – поместить определение каждого класса в отдельный заголовочный файл, а определения функций-членов в соответствующие файлы .cpp. Таким образом, все определения классов сразу же были бы видны в файлах .cpp, и не нужно было бы переупорядочивать классы и функции!
Дружественная функция или класс – это функция или класс, которые могут получить доступ к закрытым членам другого класса, как если бы они были членами этого класса. Это позволяет дружественной функции или классу тесно работать с другим классом, не заставляя другой класс открывать свои закрытые члены (например, через функции доступа).
Объявление друзьями обычно используется при определении перегруженных операторов (о которых мы поговорим в следующей главе) или, реже, когда два или более класса должны тесно взаимодействовать друг с другом.
Обратите внимание, что для того, чтобы сделать конкретную функцию-член другом, необходимо сначала увидеть полное определение класса функции-члена.
А как ты думаешь, при улучшении наследование, будет лучше нам? Надеюсь, что теперь ты понял что такое наследование, полиморфизм, внутренние классы, вложенные классы, локальные классы, дружественные классы, дружественные функции и для чего все это нужно, а если не понял, или есть замечания, то не стесняйся, пиши или спрашивай в комментариях, с удовольствием отвечу. Для того чтобы глубже понять настоятельно рекомендую изучить всю информацию из категории Объектно-ориентированное программирование ООП
чтобы еще лучше понять смысл классов интерфейсов и вообще ООП, рекомендуем прочитать UML диаграммы классов
https://intellect.icu/diagramma-klassov-class-diagram-4825
Отношения классов в UML
https://intellect.icu/otnosheniya-klassov-v-uml-4301
Комментарии
Оставить комментарий
Объектно-ориентированное программирование ООП
Термины: Объектно-ориентированное программирование ООП