Программирование предусматривает различные методологии. В зависимости от них меняется функционал выбираемых языков. Огромным спросом пользуется ООП. Здесь в основе заложено взаимодействие объектов, а не «чистая логика» и абстракции.
В данной статье будет рассказано о том, что собой представляет объектно-ориентированное программирование. Особое внимание уделено наследованию классов и иных элементов. Предложенные сведения окажутся одинаково полезны и новичкам, и продвинутым разработчикам. Акцент будет сделан на Си-семействе (С++), а также Java. Это – непревзойденные лидеры в области ООП.
ООП – определение
Это – специализированная методология программирования, которая опирается на представлении программы в виде некой связи взаимодействующий между собой объектов. Каждый из них – это экземпляр определенного класса. Классы будут образовывать иерархию наследования, о которой сказано далее.
Идеологически объектно-ориентированное программирование – это подход к написанию исходного кода утилиты как к моделированию информационных объектов. На новом уровне они решают основную задачу структурного программирования. Этот прием позволяет добиться быстрых и эффективных результатов в крупных проектах.
3.3. Наследование по закону
Принципы ООП
Каждый программер может освоить любой язык объектно-ориентированного типа. Независимо от выбранного варианта, требуется понять ключевые принципы соответствующего подхода к написанию программного обеспечения.
Вот основные принципы:
- Абстракция. Помогает выделять в моделируемом предмете важного для решения конкретных задач. В итоге понимание объекта будет трактоваться в виде класса.
- Инкапсуляция. Обеспечивает быструю и безопасную организацию иерархической управляемости. Тут ведется уточнение «что делать», а не «как добиться цели».
- Наследование. Весьма важный процесс, позволяющий организовывать родственные понятия. На каждом шаге иерархии должны быть понятны только необходимые корректировки, без дублирования «оставшихся» элементов кода.
- Полиморфизм. Нужен для того, чтобы определять точки, в которых единое управление лучше распараллелить или наоборот – скомпоновать в единое целое.
Все это помогает работать с классами, а также делать приложение максимально понятным для рядового пользователя. Через рассматриваемую методологию удается добиться высокой детализации проекта.
Терминология
Перед тем, как разработчик узнает, что такое иерархия, ему нужно запомнить несколько ключевых понятий. Они встречаются в разных языках программирования. Выступают в качестве «базы», без которой дальнейший коддинг становится невозможным:
- Алгоритм – принцип или правила, которые необходимы для достижения изначально поставленной задачи.
- API – интерфейс прикладного программирования. Представлен правилами, протоколами и процедурами, необходимыми для написания контента. Помогает приложениям взаимодействовать друг с другом.
- Аргументы – значения, передаваемые в функции и команды.
- Символы – элементарные единицы отображения электронных материалов. Выражаются цифирными или буквенными записями.
- Объект – набор связанных переменных, структур данных, а также констант. Они будут отобраны и совместно обработаны утилитой.
- Класс – набор связанных между собой объектов. У таких компонентов есть общие свойства (public).
- Константы – переменные (значения), которые не меняются на протяжении выполнения кода программы.
- Тип данных – способ классификации информации электронного характера определенного типа.
- Переменная – именованная ячейка выделенной памяти. Может при обработке кода считываться, сохраняться, изменяться согласно представленным программером алгоритмам.
- Массив – списки схожих типов значений, заранее прошедшие процедуру группировки. Множество информации.
- Фреймворк – готовый блок кода, используемый для ускорения написания программы. Может корректироваться разработчиком «под себя». Вмещает API, а также классы и объекты, иные инструменты.
- Оператор – объект, манипулирующий операндами.
- Операнд – элемент кода, которым можно управлять через специальные компоненты: операторы.
- Указатели – переменные с адресом места в памяти. Обладают уникальными именами.
- Пакет – организованный модель связанных интерфейсов и классов. Помогают организовывать классы, которые относятся к одной и той же категории или предоставляют соответствующие функциональные возможности.
Отдельно можно выделить понятие синтаксиса – это правила и принципы передачи операторов. То, как должен быть написан исходных код.
ЧТО НУЖНО ЗНАТЬ О НАСЛЕДОВАНИИ В 2023 ГОДУ. Часть 1: Что должен знать наследодатель?
Наследование – что это
При разборе тем, посвященных методам коддинга и ООП, важно обратить внимание на наследование. Это – одна из основ объектно-ориентированного программирования. При помощи нее класс сможет использовать переменные и методы другого класса, словно собственные.
Класс, который наследует данные, является подклассом. Он также носит название производного или дочернего.
Класс, который дает «базу» для наследования» — суперкласс или базовые. Может называться родительским (или просто «родителем»).
Наследование полезно, так как оно дает возможность структурирования и повторного использования кода. Это способствует более быстрой и качественной разработке. Но работа с классами и рассматриваемой операцией требует от программера осторожности. Большинство корректировок в суперклассе затрагивают все подклассы. Это влечет за собой непредвиденные последствия.
Наследование в C++
Каждый язык программирования предусматривает свои особенности и нюансы применения наследования классов. Далее будет приведен пример на C++, а затем – опубликована полезная информация для разработчиков на Java.
В Си Плюс-Плюс выделяются несколько типов наследования:
- Публичный. Это – public class. Здесь есть общие (public) и защищенные (protected) данные. Они будут наследоваться без корректировки изначально предусмотренного уровня доступа к оным.
- Защищенный. Носит название protected. Вся информация, которая была унаследована, получит статус «защищенной».
- Приватный – private. Все передаваемые электронные материалы будут «приватными».
Чтобы лучше понимать принципы и методы их работы, стоит рассмотреть наглядный пример. В нем для базового класса Device уровень доступа к электронным материалам остается неизменным. Связано это с тем, что производный класс Computer будет наследовать сведения в виде приватных. Информация для класса Computer будет приватной.
Вот так будет выглядеть пример:
#include using namespace std; class Device < public: int serial_number = 12345678; void turn_on() < cout >; class Computer: private Device < public: void say_hello() < turn_on(); cout >; int main() < Device Device_instance; Computer Computer_instance; cout
- Класс Computer будет использовать метод turn_on() точно так же, как и любой приватный.
- Turn_on может быть вызван внутри класса. Попытка обратиться к нему напрямую через main повлечет за собой ошибку во время компилирования.
- Для родительского класса Device метод turn_on выступает в качестве публичного. Он может быть вызван из main.
Все это наглядно объясняет типы наследования в C++.
Конструкторы и деструкторы
Конструкторы и деструкторы в C++ не проходят стадию наследования. Они могут быть вызваны, если дочерний класс будет инициализировать свой объект. Конструкторы будут вызываться иерархическим способом один за другим. Начало – базовый класс, конец – последний производный.
Деструкторы тоже могут быть вызваны при инициализации классом имеющегося объекта. Соответствующий процесс в данном случае осуществляется в обратном порядке по сравнению с конструкторами.
#include using namespace std; class Device < public: // constructor Device() < cout // destructor ~Device() < cout >; class Computer: public Device < public: Computer() < cout ~Computer() < cout >; class Laptop: public Computer < public: Laptop() < cout ~Laptop() < cout >; int main()
Это – пример кода, который поможет понять принцип вызова упомянутых компонентов. В виде конструкторов выступают: Device-Computer-Laptop, деструкторов: laptop-Computer-Device.
Множественное наследование
Рассматривая иерархию классов с, стоит обратить внимание на множественное наследование. Оно происходит тогда, когда подкласс имеет два или более суперкласса (ключевое слово super class).
Выше – пример того, как выглядит в виде кодификации. Здесь класс Laptop будет одновременно выступать «наследником» Monitor и Computer.
Виртуальное наследование
В C++ есть new понятие – это «виртуальное наследование». Оно:
- Позволяет предотвратить появление множественных объектов базового класса в иерархии наследования.
- Конструктор базового класса Device – вызывается один раз.
- Обращение к turn_on без предопределения «родителя» в дочернем классе не вызовет ошибку при компиляции.
Выше – наглядный пример виртуального «варианта». В классах Computer и Monitor такой подход не разрешает ромбовидное наследование, если «дочь» Laptop будет получать в качестве «наследодателя» класс Device не виртуально (class Laptop: public Computer, public Monitor, public Device <>;).
Иерархия в Java
Наследование в Java – это более понятный вариант. Освоить его принципы проще, чем в случае с C++. This method носит название «расширение класса». Ключевые понятия и определения тут точно такие же, как и в случае с Си-семейством. Поэтому слово public не должно вызывать проблемы.
Что унаследовано
При рассмотрении темы требуется запомнить:
- Когда подкласс расширяет суперкласс в Джаве, он будет наследовать защищенные и открытые (public) поля и методы. Они станут частью оной, словно подкласс сам их объявил.
- Защищенные и public поля можно вызывать и ссылаться на них, как на объявленные в их пределах методы.
- Поля и методы с модификаторами доступа по умолчанию (пакеты) бывают доступны для подклассов, если они расположены там же, где и superclass.
- На частные поля и методы (не public) суперкласса нельзя непосредственно ссылаться. Для этого используются методы, доступные для подкласса.
Как и в C++, конструкторы не подлежат рассматриваемой процедуре. Они должны вызывать конструктор для подкласса в superclass.
Единичный «подход»
Наследование в Java может быть единичным. Это – самый распространенный вариант. Он дает возможность получать свойства только от одного superclass.
Множественный вариант создает некоторые проблемы в ЯП. Пример – когда суперклассы имеют методы с одними и теми же именами и параметрами. Из Джавы такой вариант исключен. Поэтому достаточно понять права доступа и общие (public) принципы изучаемой операции.
Как объявить
Для того, чтобы воспользоваться приемом, когда уже ясно, что такое public, нужно использовать ключевик extends:
- Car будет выступать «расширителем» Vehicle.
- Соответствующее явление приводит к тому, что защищенное поле (не public) licensePlate из Vehicle перейдет в Car.
- После «получения свойств» от licensePlate, оно станет доступным внутри экземпляра Car.
Можно сослаться на Car. Делается это так:
Ссылка осуществляется внутри методы getLicensePlate. Обычно его помещают в класс Vehicle.
Приведение типов
Когда понятия public. Private, public static void и другие «базовые» для разработки поняты, можно переходить к более сложным моментам. В Джаве можно составлять на подкласс как на экземпляр одного из его суперклассов.
Сначала здесь будет создан экземпляр авто, затем он присваивается переменной типа Vehicle. Далее ссылка будет указывать на соответствующий экземпляр.
Приведение типа – это процесс ссылки на объект класса как тип, отличный от самого class a. Объект «перебрасывается» из одного вида в другой.
Upcasting и Downcasting
При разработке можно привести объект подкласса к одному из его superclass. К этому моменту пользователь должен уже хорошо разбираться в правах доступа, включая public.
Объект «наследника» может быть приведен к:
- одному из его «родителей»;
- из типа superclass к типу подкласса, если объект действительно выступает его экземпляром.
Приведенный пример downcasting будет действителен. А здесь можно посмотреть туториал по наследованию классов.
Как лучше понять процесс
Рассматривать соответствующую тему в «голой теории» — не лучшее решение. Понятия public и private можно изучить «только на бумаге». В случае с более сложными компонентами огромную роль играет практика. А еще – грамотно подобранный материал.
Здесь рассказывается о выбранном направлении в ООП в общих чертах. А тут – основы для C++.
Необходимые знания можно получить при помощи самообразования, а также обучаясь в техникуме или ВУЗе на направлении «программирование». Там рассказывают о наследовании в Java и других ЯП, разбирая процесс «с нуля».
Но лучшее решение – это дистанционные компьютерные курсы. Пользователи смогут заниматься тогда, когда им удобно. Программы рассчитаны как на новичков, так и на опытных разработчиков. Можно освоить одновременно несколько направлений в течении года. В конце выдается электронный сертификат, подтверждающий навыки и знания.
С такими курсами элементы кода как static void main, superclass, public и другие будут понятны даже новичку.
Источник: otus.ru
1. Парадигмы программирования, основные направления в программировании.
Парадигма программирования это определенный набор принципов для написания компьютерной программы. Самые популярные парадигмы программирования:
- Императивное программирование
- Структурное программирование
- Декларативное программирование
- Объектно-ориентированное программирование
- Отличительные черты императивного программирования:
В исходном коде записываются «приказы» команды, а не классы, как в отличии например от объектно-ориентированного программирования. Все инструкции должны выполняться последовательно, один за другим (например мы не можем перескакивать с одного участка кода на другой). После выполнения инструкций данные могут записываться в память и считываться памяти.
- Основным в структурном программировании является понятие блоков и иерархической структуры и в которой используются три основных управляющих структур: последовательность, цикл,ветвление
- Декларативное программирование представляет собой спецификацию решения задачи, и описывает что такое проблема и ожидаемый результат от работы. Противопоставляется императивному программированию потому что в декларативном программирование описывается что сделать, а в другом как сделать.
- Объектно-ориентированное программирование (ООП):
Является самым популярном и общеиспользуемой парадигмой принятой во всем мире почти всеми программистами. Всё промышленное программирование построено на этом. Основная идея заключается в том чтобы представить программу в виде объектов который в свою очередь представляет экземпляром класса, а классы в свою очередь образуют иерархию наследования.
Основные направления программирования:
· Разработка серверных приложений
· Разработка мобильных приложений
· Программирование встраиваемых систем
· Олимпиадное программирование и решение задач
· Программирование для бухгалтерских и финансовых продуктов
· Программирование баз данных
2.Возникновение ооп
Возникновению ООП сопутствовало несколько причин:
- Усложнение задач, которые стояли перед программистами
- Усложнение задач поставило программистов перед необходимостью делить задачу на части. Но в процедурном программировании сделать это было не так просто.Эта необходимость стала еще одной причиной возникновения ООП.
«SIMULA I (1962-65) и Simula 67 (1967) — два первых объектно-ориентированных языка программирования. Simula 67 включала в себя большую часть концепций объектно-ориентированного программирования: классы и объекты, подклассы (наследование), виртуальные функции, безопасные ссылки и механизмы, позволяющие внести в программу коллекцию программных структур, описанных общим заголовком класса (префиксные блоки).
Бьерн Страусструпп начал разработку C++ (в 1980-х) by привнеся основные концепции Simula в С.
Источник: studfile.net
Наследование в C++: beginner, intermediate, advanced
В этой статье наследование описано на трех уровнях: beginner, intermediate и advanced. Expert нет. И ни слова про SOLID. Честно.
Beginner
Что такое наследование?
Наследование является одним из основополагающих принципов ООП. В соответствии с ним, класс может использовать переменные и методы другого класса как свои собственные.
Класс, который наследует данные, называется подклассом (subclass), производным классом (derived class) или дочерним классом (child). Класс, от которого наследуются данные или методы, называется суперклассом (super class), базовым классом (base class) или родительским классом (parent). Термины “родительский” и “дочерний” чрезвычайно полезны для понимания наследования. Как ребенок получает характеристики своих родителей, производный класс получает методы и переменные базового класса.
Наследование полезно, поскольку оно позволяет структурировать и повторно использовать код, что, в свою очередь, может значительно ускорить процесс разработки. Несмотря на это, наследование следует использовать с осторожностью, поскольку большинство изменений в суперклассе затронут все подклассы, что может привести к непредвиденным последствиям.
В этом примере, метод turn_on() и переменная serial_number не были объявлены или определены в подклассе Computer . Однако их можно использовать, поскольку они унаследованы от базового класса.
Важное примечание: приватные переменные и методы не могут быть унаследованы.
#include using namespace std; class Device < public: int serial_number = 12345678; void turn_on() < cout private: int pincode = 87654321; >; class Computer: public Device <>; int main() < Computer Computer_instance; Computer_instance.turn_on(); cout
Типы наследования
В C ++ есть несколько типов наследования:
- публичный ( public )- публичные ( public ) и защищенные ( protected ) данные наследуются без изменения уровня доступа к ним;
- защищенный ( protected ) — все унаследованные данные становятся защищенными;
- приватный ( private ) — все унаследованные данные становятся приватными.
Для базового класса Device , уровень доступа к данным не изменяется, но поскольку производный класс Computer наследует данные как приватные, данные становятся приватными для класса Computer .
#include using namespace std; class Device < public: int serial_number = 12345678; void turn_on() < cout >; class Computer: private Device < public: void say_hello() < turn_on(); cout >; int main() < Device Device_instance; Computer Computer_instance; cout
Класс Computer теперь использует метод turn_on() как и любой приватный метод: turn_on() может быть вызван изнутри класса, но попытка вызвать его напрямую из main приведет к ошибке во время компиляции. Для базового класса Device , метод turn_on() остался публичным, и может быть вызван из main .
Конструкторы и деструкторы
В C ++ конструкторы и деструкторы не наследуются. Однако они вызываются, когда дочерний класс инициализирует свой объект. Конструкторы вызываются один за другим иерархически, начиная с базового класса и заканчивая последним производным классом. Деструкторы вызываются в обратном порядке.
Важное примечание: в этой статье не освещены виртуальные десктрукторы. Дополнительный материал на эту тему можно найти к примеру в этой статье на хабре.
#include using namespace std; class Device < public: // constructor Device() < cout // destructor ~Device() < cout >; class Computer: public Device < public: Computer() < cout ~Computer() < cout >; class Laptop: public Computer < public: Laptop() < cout ~Laptop() < cout >; int main()
Конструкторы: Device -> Computer -> Laptop .
Деструкторы: Laptop -> Computer -> Device .
Множественное наследование
Множественное наследование происходит, когда подкласс имеет два или более суперкласса. В этом примере, класс Laptop наследует и Monitor и Computer одновременно.
#include using namespace std; class Computer < public: void turn_on() < cout >; class Monitor < public: void show_image() < cout >; class Laptop: public Computer, public Monitor <>; int main()
Проблематика множественного наследования
Множественное наследование требует тщательного проектирования, так как может привести к непредвиденным последствиям. Большинство таких последствий вызваны неоднозначностью в наследовании. В данном примере Laptop наследует метод turn_on() от обоих родителей и неясно какой метод должен быть вызван.
#include using namespace std; class Computer < private: void turn_on() < cout >; class Monitor < public: void turn_on() < cout >; class Laptop: public Computer, public Monitor <>; int main() < Laptop Laptop_instance; // Laptop_instance.turn_on(); // will cause compile time error return 0; >
Несмотря на то, что приватные данные не наследуются, разрешить неоднозначное наследование изменением уровня доступа к данным на приватный невозможно. При компиляции, сначала происходит поиск метода или переменной, а уже после — проверка уровня доступа к ним.
Intermediate
Проблема ромба
Проблема ромба (Diamond problem)- классическая проблема в языках, которые поддерживают возможность множественного наследования. Эта проблема возникает когда классы B и C наследуют A , а класс D наследует B и C .
К примеру, классы A , B и C определяют метод print_letter() . Если print_letter() будет вызываться классом D , неясно какой метод должен быть вызван — метод класса A , B или C . Разные языки по-разному подходят к решению ромбовидной проблем. В C ++ решение проблемы оставлено на усмотрение программиста.
Ромбовидная проблема — прежде всего проблема дизайна, и она должна быть предусмотрена на этапе проектирования. На этапе разработки ее можно разрешить следующим образом:
- вызвать метод конкретного суперкласса;
- обратиться к объекту подкласса как к объекту определенного суперкласса;
- переопределить проблематичный метод в последнем дочернем классе (в коде — turn_on() в подклассе Laptop ).
#include using namespace std; class Device < public: void turn_on() < cout >; class Computer: public Device <>; class Monitor: public Device <>; class Laptop: public Computer, public Monitor < /* public: void turn_on() < cout // uncommenting this function will resolve diamond problem */ >; int main() < Laptop Laptop_instance; // Laptop_instance.turn_on(); // will produce compile time error // if Laptop.turn_on function is commented out // calling method of specific superclass Laptop_instance.Monitor::turn_on(); // treating Laptop instance as Monitor instance via static cast static_cast( Laptop_instance ).turn_on(); return 0; >
Если метод turn_on() не был переопределен в Laptop, вызов Laptop_instance.turn_on() , приведет к ошибке при компиляции. Объект Laptop может получить доступ к двум определениям метода turn_on() одновременно: Device:Computer:Laptop.turn_on() и Device:Monitor:Laptop.turn_on() .
Проблема ромба: Конструкторы и деструкторы
Поскольку в С++ при инициализации объекта дочернего класса вызываются конструкторы всех родительских классов, возникает и другая проблема: конструктор базового класса Device будет вызван дважды.
#include using namespace std; class Device < public: Device() < cout >; class Computer: public Device < public: Computer() < cout >; class Monitor: public Device < public: Monitor() < cout >; class Laptop: public Computer, public Monitor <>; int main()
Виртуальное наследование
Виртуальное наследование (virtual inheritance) предотвращает появление множественных объектов базового класса в иерархии наследования. Таким образом, конструктор базового класса Device будет вызван только единожды, а обращение к методу turn_on() без его переопределения в дочернем классе не будет вызывать ошибку при компиляции.
#include using namespace std; class Device < public: Device() < cout void turn_on() < cout >; class Computer: virtual public Device < public: Computer() < cout >; class Monitor: virtual public Device < public: Monitor() < cout >; class Laptop: public Computer, public Monitor <>; int main()
Примечание: виртуальное наследование в классах Computer и Monitor не разрешит ромбовидное наследование если дочерний класс Laptop будет наследовать класс Device не виртуально ( class Laptop: public Computer, public Monitor, public Device <>; ).
Абстрактный класс
В С++, класс в котором существует хотя бы один чистый виртуальный метод (pure virtual) принято считать абстрактным. Если виртуальный метод не переопределен в дочернем классе, код не скомпилируется. Также, в С++ создать объект абстрактного класса невозможно — попытка тоже вызовет ошибку при компиляции.
#include using namespace std; class Device < public: void turn_on() < cout virtual void say_hello() = 0; >; class Laptop: public Device < public: void say_hello() < cout >; int main() < Laptop Laptop_instance; Laptop_instance.turn_on(); Laptop_instance.say_hello(); // Device Device_instance; // will cause compile time error return 0; >
Интерфейс
С++, в отличии от некоторых ООП языков, не предоставляет отдельного ключевого слова для обозначения интерфейса (interface). Тем не менее, реализация интерфейса возможна путем создания чистого абстрактного класса (pure abstract class) — класса в котором присутствуют только декларации методов. Такие классы также часто называют абстрактными базовыми классами (Abstract Base Class — ABC).
#include using namespace std; class Device < public: virtual void turn_on() = 0; >; class Laptop: public Device < public: void turn_on() < cout >; int main() < Laptop Laptop_instance; Laptop_instance.turn_on(); // Device Device_instance; // will cause compile time error return 0; >
Advanced
Несмотря на то, что наследование — фундаментальный принцип ООП, его стоит использовать с осторожностью. Важно думать о том, что любой код который будет использоваться скорее всего будет изменен и может быть использован неочевидным для разработчика путем.
Наследование от реализованного или частично реализованного класса
Если наследование происходит не от интерфейса (чистого абстрактного класса в контексте С++), а от класса в котором присутствуют какие-либо реализации, стоит учитывать то, что класс наследник связан с родительским классом наиболее тесной из возможных связью. Большинство изменений в классе родителя могут затронуть наследника что может привести к непредвиденному поведению. Такие изменения в поведении наследника не всегда очевидны — ошибка может возникнуть в уже оттестированом и рабочем коде. Данная ситуация усугубляется наличием сложной иерархии классов. Всегда стоит помнить о том, что код может изменяться не только человеком который его написал, и пути наследования очевидные для автора могут быть не учтены его коллегами.
В противовес этому стоит заметить что наследование от частично реализованных классов имеет неоспоримое преимущество. Библиотеки и фреймворки зачастую работают следующим образом: они предоставляют пользователю абстрактный класс с несколькими виртуальными и множеством реализованных методов. Таким образом, наибольшее количество работы уже проделано — сложная логика уже написана, а пользователю остается только кастомизировать готовое решение под свои нужды.
Интерфейс
Наследование от интерфейса (чистого абстрактного класса) преподносит наследование как возможность структурирования кода и защиту пользователя. Так как интерфейс описывает какую работу будет выполнять класс-реализация, но не описывает как именно, любой пользователь интерфейса огражден от изменений в классе который реализует этот интерфейс.
Интерфейс: Пример использования
Прежде всего стоит заметить, что пример тесно связан с понятием полиморфизма, но будет рассмотрен в контексте наследования от чистого абстрактного класса.
Приложение выполняющее абстрактную бизнес логику должно настраиваться из отдельного конфигурационного файла. На раннем этапе разработки, форматирование данного конфигурационного файла до конца сформировано не было. Вынесение парсинга файла за интерфейс предоставляет несколько преимуществ.
Отсутствие однозначности касательно форматирования конфигурационного файла не тормозит процесс разработки основной программы. Два разработчика могут работать параллельно — один над бизнес логикой, а другой над парсером. Поскольку они взаимодействуют через этот интерфейс, каждый из них может работать независимо. Данный подход облегчает покрытие кода юнит тестами, так как необходимые тесты могут быть написаны с использованием мока (mock) для этого интерфейса.
Также, при изменении формата конфигурационного файла, бизнес логика приложения не затрагивается. Единственное чего требует полный переход от одного форматирования к другому — написания новой реализации уже существующего абстрактного класса (класса-парсера). В дальнейшем, возврат к изначальному формату файла требует минимальной работы — подмены одного уже существующего парсера другим.
Заключение
Наследование предоставляет множество преимуществ, но должно быть тщательно спроектировано во избежание проблем, возможность для которых оно открывает. В контексте наследования, С++ предоставляет широкий спектр инструментов который открывает массу возможностей для программиста.
Источник: habr.com