к какому принципу ооп относятся понятия прав доступа и модификаторов public

ООП. Часть 3. Модификаторы доступа, инкапсуляция

Классы, методы и поля не всегда могут постоять за себя. Рассказываем, как быть защитником в объектно-ориентированном программировании.

Инкапсуляция (от лат. in capsule — в оболочке) — это заключение данных и функционала в оболочку. В объектно-ориентированном программировании в роли оболочки выступают классы: они не только собирают переменные и методы в одном месте, но и защищают их от вмешательства извне (сокрытие).

Важно! Инкапсуляция не является сокрытием. Сокрытие — это часть инкапсуляции.

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

Все статьи про ООП

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

Модификатор доступа public

Первый уровень, с которым сталкиваются все разработчики, — публичный. Чтобы сказать компилятору, что что-то должно быть доступно для всех, используется ключевое слово public.

Рассмотрим на примере класса Item:

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

Так как поля публичные, в консоли они отобразятся без каких-либо проблем:

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

Из-за того, что поле публичное, оно изменится:

Это плохо по нескольким причинам:

Разумеется, это не лучшее, что может случиться с приложением.

Модификатор доступа private

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

Теперь эти поля нельзя будет изменить нигде, кроме как в методах этого класса. Но и получить их значение извне тоже не получится, а попытка вывести приведёт к ошибке:

Есть два способа сделать поле доступным только для чтения. Первый — использовать ключевое слово readonly, но оно запрещает менять значение вообще.

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

К такой практике прибегают Java-разработчики, но в C# есть более элегантный способ — свойства.

Теперь, чтобы получить данные, нужно обратиться к свойству, а не к полю:

Преимущество этого в том, что можно разрешить получать данные, но запретить их менять. То есть прописать только геттер:

Обратите внимание, что можно просто написать set; или get; если не требуется дополнительная логика. Это сработает, если у поля и свойства одинаковые имена и если это примитивный тип (int, float, char, double и другие). Со ссылочными типами (объекты и строки) это не работает.

Также можно менять логику работы со значением:

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

То есть если запустить вот такой код:

Также можно создавать свойства без поля:

Это свойство вернёт true, если цена выше 5000, и false, если ниже.

Ключевое слово private можно также применять и к методам. Это делает их доступными только внутри класса.

Также приватным можно сделать сам класс, если он находится внутри другого класса:

Модификатор доступа internal

Иногда нужно сделать компонент доступным только внутри одного файла — например, в Program.cs, Item.cs или любом другом. Для этого используется ключевое слово internal.

Класс Backpack можно будет использовать только внутри файла Program.cs, и попытка объявить его внутри другого файла приведёт к ошибке.

Ключевое слово static

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

Метод Sum () используется в классе Program, хотя экземпляр класса Calc не создавался. При этом можно сделать статичным как отдельный метод или свойство, так и весь класс. В этом случае все поля и методы тоже должны быть статичными.

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

Другой пример — класс Math. Его можно использовать, чтобы выполнять различные математические операции (получение квадратного корня, модуляция, получение синуса, косинуса и так далее). У него много методов, а также он хранит различные константы вроде числа пи.

Домашнее задание

Напишите класс GameObject, в котором будут храниться координаты объекта. Координаты должны быть доступны для чтения, а их изменение должно происходить в методе Move ().

Заключение

Есть и другие ключевые слова:

Они будут рассмотрены в статье о наследовании.

Большая часть курса «Профессия С#-разработчик» посвящена именно ООП —
не только теории, но и практике. Вы научитесь писать программы, подбирая нужные инструменты — от инкапсуляции до полиморфизма. К концу курса у вас будет портфолио из нескольких проектов, а также все знания и навыки, которые нужны для получения первой работы.

Источник

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

Привет, Хабр! Меня зовут Владислав Родин. В настоящее время я являюсь руководителем курса «Архитектор высоких нагрузок» в OTUS, а также преподаю на курсах, посвященных архитектуре ПО.

Специально к старту занятий в новом потоке курса «Архитектура и шаблоны проектирования» я подготовил еще один авторский материал.

Введение

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

Вообще устроено все следующим образом: есть само объектно-ориентированное программирование. У него есть принципы. Из принципов объектно-ориентированного программирования следуют разобранные нам шаблоны GRASP (как вариант — SOLID принципы), из которых, в свою очередь, следуют шаблоны GoF. Из них же следует ряд интересных вещей, например, enterprise паттерны.

Объектно-ориентированная парадигма

Определение гласит, что «Объектно-ориентированное программирование – это парадигма программирования, в которой основной концепцией является понятие объекта, который отождествляется с предметной областью.»

Таким образом, система представляется в виде набора объектов предметной области, которые взаимодействуют между собой некоторым образом. Каждый объект обладает тремя cоставляющими: идентичность (identity), состояние (state) и поведение (behaviour).

Состояние объекта — это набор всех его полей и их значений.

Поведение объекта — это набор всех методов класса объекта.

Идентичность объекта — это то, что отличает один объект класса от другого объекта класса. С точки зрения Java, именно по идентичности определяется метод equals.

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

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

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

Вопреки мнению многих собеседующихся (а иногда и собеседуемых), инкапсуляция это не «когда все поля приватные». Инкапсуляция является фундаментальнейшим принципом проектирования ПО, ее следы наблюдаются на только на уровне микро-, но и на уровне макропроектирования.

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

Таким образом, получается, что если класс A обращается к полям класса B напрямую, это приводит не к тому, что «нарушается информационная безопасность», а к тому, что класс A завязывается на внутренне устройство класса B, и попытка изменить внутреннее устройство класса B приведет к изменению класса А. Более того, класс A не просто так работает с полями класса B, он работает по некоторой бизнес-логике. То есть логика по работе с состоянием класса В лежит в классе А, и когда мы захотим переиспользовать класс В, это не удастся сделать, ведь без кусочка класса А класс В может быть бесполезным, что приведет к тому, что класс В придется отдавать вместе с классом А. Экстраполируя это на всю систему, получается, что переиспользовать можно будет только всю систему целиком.

Инкапсуляция является самым недооцененным принципом, который, к сожалению, мало кем интерпретируется правильно. Она позволяет минимизировать число связей между классами и подсистемами и, соответственно, упростить независимую реализацию и модификацию классов и подсистем.

Наследование

Наследование — это возможность порождать один класс от другого с сохранением всех свойств и методов класса-предка (суперкласса), добавляя при необходимости новые свойства и
методы.

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

Полиморфизм

Полиморфизм — это возможность использовать классы – потомки в контексте, который был предназначен для класса – предка.

За самым садистским определением кроется возможность языка программирования для декомпозиции задачи и рефакторинга if’ов и switch’ей.

Источник

Введение в ООП с примерами на C#. Часть пятая. Всё о модификаторах доступа

Авторизуйтесь

Введение в ООП с примерами на C#. Часть пятая. Всё о модификаторах доступа

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

Что такое модификаторы доступа?

Давайте в этот раз возьмём определение из Википедии (в русской Википедии статьи access modifiers нет, поэтому здесь приводим свой перевод — прим. перев.) :

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

Модификаторы public, private, protected

Традиционно сразу переходим к практике. Давайте попробуем выполнить следующий код:

Результатом выполнения этого кода будет:

Теперь попробуем получить доступ к AAA() напрямую:

‘AccessModifiers.Modifiers.AAA()’ is inaccessible due to its protection level

Модификаторы доступа и наследование

Снова попробуем выполнить код:

Запускаем код и видим…

‘AccessModifiers.ModifiersBase.AAA()’ is inaccessible due to its protection level

Приватные члены недоступны даже дочерним классам. Публичные члены доступны всем, это понятно. Модификатор же protected по сути и обозначает, что член доступен только дочерним классам — вызов CCC() в примере выше не вызывает никаких ошибок.

Модификатор Internal для классов

Давайте рассмотрим следующий сценарий: мы создаём в новой библиотеке классов (назовём её AccessModifiersLibrary ) класс ClassA и помечаем его как internal :

Теперь в созданном ранее файле попробуем выполнить:

Compile time error: ‘AccessModifiersLibrary.ClassA’ is inaccessible due to its protection level

Модификаторы для пространств имён

Давайте попробуем сделать с предыдущим кодом следующее:

Конечно, это не скомпилируется:

Compile time error: A namespace declaration cannot have modifiers or attributes

Приватные классы

Если мы попробуем скомпилировать код, приведённый выше, то получим ошибку:

Compile time error: Elements defined in a namespace cannot be explicitly declared as private, protected, or protected internal

Подробнее о модификаторах членов класса

Что будет, если мы захотим назначить члену класса больше одного модификатора доступа?

Будет ошибка компиляции:

Compile time error: More than one protection modifier

А как поведёт себя язык, если мы создадим public метод в internal классе?

Вывод после компиляции:

‘AccessModifiersLibrary.ClassA’ is inaccessible due to its protection level

The type ‘AccessModifiersLibrary.ClassA’ has no constructors defined

‘AccessModifiersLibrary.ClassA’ is inaccessible due to its protection level

‘AccessModifiersLibrary.ClassA’ does not contain a definition for ‘MethodClassA’ and
no extension method ‘MethodClassA’ accepting a first argument of type ‘AccessModifiersLibrary.ClassA’
could be found (are you missing a using directive or an assembly reference?)

Как много ошибок… Дело в том, что какими бы модификаторами не обладали члены internal класса, их всё равно нельзя вызвать оттуда, где не виден сам класс. А что будет, если мы попробуем сделать наоборот — вызвать private или internal метод у public класса?

‘AccessModifiersLibrary.ClassA’ does not contain a definition
for ‘MethodClassA’ and no extension method ‘MethodClassA’ accepting a first argument
of type ‘AccessModifiersLibrary.ClassA’ could be found (are you missing a using directive or an assembly reference?)

‘AccessModifiersLibrary.ClassA’ does not contain a definition for ‘MethodClassA’ and no extension
method ‘MethodClassA’ accepting a first argument of type ‘AccessModifiersLibrary.ClassA’ could be
found (are you missing a using directive or an assembly reference?)

Увы, так делать тоже нельзя.

Модификатор protected internal

Этот код компилируется без ошибок. Модификатор internal proteted (как не слишком сложно догадаться) даёт понять, что метод доступен как для вызовов из того же файла, в котором он объявлен, так и для вызовов из дочерних классов.

Protected поля

Здесь всё будет немного сложнее. Давайте напишем следующий код:

Если мы его запустим, то получим ошибку:

Cannot access protected member ‘AccessModifiers.AAA.a’ via a qualifier of type ‘AccessModifiers.AAA’;
the qualifier must be of type ‘AccessModifiers.BBB’ (or derived from it)

(От редакции) Скорее всего, это сделано, чтобы нельзя было делать следующим образом:

Приоритет модификаторов

Compile time error: Inconsistent accessibility: base class ‘AccessModifiers.AAA’ is less accessible than class ‘AccessModifiers.BBB’

Inconsistent accessibility: return type ‘AccessModifiers.AAA’ is less accessible than method ‘AccessModifiers.BBB.MethodB()’

Inconsistent accessibility: field type ‘AccessModifiers.AAA’ is less accessible than field ‘AccessModifiers.BBB.aaa’

Подведём итоги:

Работу с константами и sealed классами (которая тоже осуществляется за счёт модификаторов доступа) мы разберём в следующей статье.

Источник

Какие модификаторы доступа существуют в Java?

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

Следующая таблица суммирует, к каким конструкциям Java может применяться каждый модификатор:

Private

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

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

Вот пример назначения к полю:

Переменная – long time была помечена как частная. Это означает, что переменная long time внутри класса Clock недоступна из кода вне него.

Доступ к частным полям

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

В приведенном выше примере два метода getTime() и setTime() могут получить доступ к переменной long time. Два метода объявлены как публичные, то есть они могут быть вызваны из кода в любом месте вашего приложения.

Частные конструкторы

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

Эта версия класса Clock содержит приватный конструктор и публичный конструктор. Закрытый конструктор вызывается из публичного (оператор this();). Он также вызывается из статического метода newClock().

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

Default

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

Подклассы не могут получить доступ к методам и переменным-членам (полям) в суперклассе, если эти методы и поля помечены этим модификатором, если только подкласс не находится в том же пакете, что и суперкласс.

Поле времени в классе Clock не имеет модификатора, что означает, что ему неявно назначен по умолчанию. Следовательно, класс ClockReader может считывать переменную-член time объекта Clock при условии, что ClockReader и Clock находятся в одном и том же пакете Java.

Protected

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

В вышеприведенном примере у подкласса SmartClock есть метод getTimeInSeconds(), который обращается к переменной времени Clock суперкласса. Это возможно, даже если Clock и SmartClock не находятся в одном и том же пакете, поскольку поле времени помечено соответствующим модификатором.

Public

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

Поле времени в классе Clock помечено общедоступным модификатором. Поэтому класс ClockReader может обращаться к полю времени в Clock независимо от того, в каком пакете находится ClockReader.

Доступ к классу

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

Частные и защищенные модификаторы не могут быть назначены классу. Только для конструкторов, методов и полей внутри классов. Классам могут быть назначены только по умолчанию (пакет) и общедоступный.

К интерфейсу

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

Модификаторы и наследование

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

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

Хотя не разрешено уменьшать доступность переопределенного метода, разрешено расширять доступность переопределенного метода. Например, если методу назначен модификатор по умолчанию в суперклассе, то разрешается назначать переопределенный метод в подклассе модификатору открытого доступа.

Источник

ООП в Java: четыре принципа с примерами

Объектно-ориентированное программирование (ООП) — это методология программирования с использованием объектов и классов.

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

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

В классах Java состояние представлено в виде полей, а поведение — в виде методов.

Содержание статьи:

Принципы ООП

Объектно-ориентированное программирование опирается на четыре принципа:

Рассмотрим эти принципы подробнее.

Наследование

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

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

Создадим базовый класс Animal, который описывает животное.

Допустим, у животного есть имя и оно издает какой-то звук. Определим имя и звук как строковые поля.

Ключевое слово private — это модификатор доступа, который означает, что поле будет доступно только в данном классе и его подклассах. Таким образом мы запрещаем изменение значений двух полей этого класса извне.

Чтобы создать экземпляр класса (объект) и задать начальные значения полей, объявим общедоступный конструктор, используя модификатор доступа public. Он позволит обращаться к конструктору извне.

Ключевое слово this — это ссылка на создаваемый объект. Для обращения к полю внутри объекта используется синтаксис:

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

На данном этапе уже реализовано состояние объекта. Теперь реализуем его поведение.

Мы объявили общедоступный метод speak(), в котором на консоли выводится значение поля voice.

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

Благодаря наследованию нам не пришлось еще раз писать код, чтобы дать коту имя и указать звук, который он издает. Имя конкретного кота мы заранее не знаем, но знаем, что коты мяукают. Поэтому конструктор этого класса принимает только один формальный параметр name.

Для обращения к суперклассу из подкласса используется ключевое слово super. В данном случае мы вызываем конструктор суперкласса и передаем ему формальный параметр name и литерал meow. Конструктор суперкласса присваивает унаследованным переменным объекта переданные значения.

Теперь мы можем создать экземпляр класса Cat и воспользоваться методом speak(), унаследованным от суперкласса, чтобы «услышать», как мяукает кот.

В языке Java все (точнее, почти все) является объектом. Поэтому мы создаем класс Main с методом main, в котором содержатся инструкции программы. В нем мы объявляем переменную класса Cat для создания объекта. Чтобы инициализировать его, обращаемся к конструктору, используя ключевое слово new, и задаем имя питомца:

Полный код будет выглядеть так:

Абстракция

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

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

Создадим класс Person и определим в нем общие характеристики.

Унаследуем от него классы Customer и Employee. Добавим для клиента номер банковского счета, а для сотрудника — размер зарплаты.

Так, мы избавились от повторного написания кода, выделив общие признаки в суперкласс. Рабочий пример выглядит так:

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

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

Площадь прямоугольника равна произведению длин его сторон. Площадь треугольника по сторонам можно вычислить по формуле Герона. Создадим абстрактный класс Area, который будет представлять геометрическую фигуру.

Абстрактный класс, как и его абстрактный метод, объявляются с помощью ключевого слова abstract. Абстрактный метод не имеет реализации, он лишь объявлен в коде класса.

Создадим производные классы Rectangle и Triangle.

В этих классах объявлены стороны и переопределен унаследованный метод area().

Стороны объявлены с использованием модификатора final, который означает, что значение данного поля — это константа, и поэтому не может быть изменено во время выполнения программы. Если объявить класс как final, то он не сможет иметь подклассов.

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

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

Полный код будет выглядеть так:

Хоть площадь этих фигур определяется по разным формулам, мы просто вызываем метод area(), не заботясь о том, как производятся вычисления.

Полиморфизм

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

Рассмотрим полный пример кода:

Обратите внимание, что в определении суперкласса мы используем модификатор protected для поля name. Этот модификатор позволяет обращаться к нему не только из данного класса, но и из его подклассов. Прямой доступ извне по-прежнему закрыт.

В методе Main мы создаем список объектов класса Musician, в котором могут находиться и экземпляры унаследованных от него классов:

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

Причины появления ООП

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

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

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

Если требовалось внести изменения или улучшить код, это стало происходить незаметно для пользователя, потому что интерфейс не менялся. Кроме того, наследование давало возможность повторно использовать код.

ООП упрощает понимание кода и позволяет экономить много времени при его написании.

Источник