Что фактически означает принцип наследования в ооп

Обновлено: 02.07.2024

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

  • Абстракция. Абстракция означает использование простых вещей для описания чего-то сложного. Например, мы все знаем как пользоваться телевизором, но в тоже время нам не нужно обладать знаниями о том, как он работает чтобы смотреть его. В Java под абстракцией подразумеваются такие вещи, как объекты, классы и переменные, которые в свою очередь лежат в основе более сложного кода. Использование данного принципа позволяет избежать сложности при разработке ПО.
  • Инкапсуляция. Под инкапсуляцией подразумевается сокрытие полей внутри объекта с целью защиты данных от внешнего, бесконтрольного изменения со стороны других объектов. Доступ к данным (полям) предоставляется посредством публичных методов (геттеров/сеттеров). Это защитный барьер позволяет хранить информацию в безопасности внутри объекта.
  • Наследование. Это особая функциональность в объектно-ориентированных языках программирования, которая позволяет описывать новые классы на основе уже существующих. При этом поля и методы класса-предка становятся доступны и классам-наследникам. Данная фича делает классы более чистыми и понятным за счет устранения дублирования программного кода.
  • Полиморфизм. Данный принцип позволяет программистам использовать одни и те же термины для описания различного поведения, зависящего от контекста. Одной из форм полиморфизма в Java является переопределение метода, когда различные формы поведения определяются объектом из которого данный метод был вызван. Другой формой полиморфизма является перегрузка метода, когда его поведение определяется набором передаваемых в метод аргументов.

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

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

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

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

Этот же подход можно использовать и в объектно-ориентированных языках программирования, таких как Java.

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

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

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

Рассмотрим примеры полиморфизма в Java: переопределение и перегрузка методов.

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

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

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

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

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

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

Принципы ООП

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

  • Наследование — это передача всех свойств и поведения от одного класса другому, более конкретному. У карася и ерша, как и у всех рыб, есть плавники, хвосты, жабры и чешуя, они живут в воде и плавают.
  • Абстракция — это сокрытие подробностей и предоставление пользователю лишь самых важных характеристик объекта. Например, в адресе здания важны такие данные, как почтовый индекс, страна, населенный пункт, улица и номер дома. Его этажность и материал стен в таком случае не имеют значения.
  • Инкапсуляция — это размещение данных и методов для их обработки в одном объекте, а также сокрытие деталей его реализации. Мы знаем, как включать и выключать телевизор, переключать программы и регулировать громкость. Для этого не обязательно знать, как он устроен.
  • Полиморфизм — это проявление одного поведения разными способами. Животные могут издавать звуки, при этом кошка мяукает, а собака лает.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

В языке 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(). Поскольку этот метод реализован во всех классах, не приходится заботиться о том, на чем именно играет каждый музыкант, и писать код вызова метода для каждого из них отдельно.

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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


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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

[an error occurred while processing this directive]

Конспект лекций по Java. Занятие 8

[an error occurred while processing this directive](none) [an error occurred while processing this directive](none)[an error occurred while processing this directive] ::
[an error occurred while processing this directive] (none)
[an error occurred while processing this directive] ([an error occurred while processing this directive] В.Фесюнов [an error occurred while processing this directive])

[an error occurred while processing this directive](none)

  • Модификаторы доступа при наследовании
  • Наследование классов — инструмент построения абстракций
  • Преобразования типов (классов) при наследовании
  • Полиморфизм
  • Ключевое слово final (Отступление)
  • Абстрактные классы
  • Интерфейсы

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

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

  • public — означает, что данный элемент доступен без каких-либо ограничений;
  • private — доступ разрешен только из данного класса;
  • protected — доступ разрешен из данного класса и из всех классов-потомков
  • без описателя — доступ разрешен из всех классов данного пакета

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

Наследование классов — инструмент построения абстракций

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

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

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

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

В визуальном представлении дерева наследования его изображают сверху вниз - от базовых классов к производным. На основе такого представления формируется и терминология (например, upcasting и downcasting, см. ниже).

Тип "Птицы" включает в себя свойства, характерные для всех птиц. А порожденные от него типы "Вороны" и "Попугаи" добавляют (каждый) какие-то свойства, характерные только для данных видов птиц.

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

Приведенные примеры демонстрируют не усложнение, а детализацию и конкретизацию классов при наследовании. Именно это является основным общепринятым принципом при построении дерева наследования классов: наверху — наиболее общие, абстрактные понятия, и при движении вниз по дереву иерархии они детализируются.

Можно поставить такую абстрактную задачу.

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

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

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

Продолжим знакомство с возможностями аппарата наследования классов.

Преобразования типов (классов) при наследовании

Аппарат наследования классов предусматривает возможности преобразования типов между суперклассом и подклассом. Преобразование типов в каком-то смысле является формальным. Сам объект при таком преобразовании не изменяется, преобразование относится только к типу ссылки на объект .

Рассмотрим это на примере.

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

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

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

Все это выглядит странно, для тех, кто не знаком с ООП. Действительно, получается, что единственная допустимая ситуация, когда такое преобразование возможно, это когда мы построили объект класса B, где B вляется подклассом A, затем зачем-то преобразовали его к классу A, а потом, опять же непонятно для чего, преобразовали его обратно к классу B.

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

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

Получив какие-то результаты от программного кода класса A, нужно опять вернуться к работе с классом B (downcasting). Это один из типичных сценариев, требующих преобразования типов как в одну, так и в другую сторону.

В Java для проверки типа объекта есть операция instanceof . Она часто применяется при понижающем (downcasting) преобразовании. Эта операция проверяет, имеет ли ее левый операнд класс, заданный правым операндом.

Рассмотрим несколько более содержательный пример, в котором применяются оба вида преобразований, а также операция instanceof.

Пример

Рассмотрим иерархию классов (Issue — печатное издание, Book — книга, Newspaper - газета, Journal — журнал).

Пусть классы Issue и Book реализованы след. образом:

где-то в программе присутствует такой фрагмент

Рассмотрим его более детально. Здесь порождается каталог (массив печатных изданий), причем каждое из печатных изданий каталога может быть как книгой, так и газетой или журналом. При построении массива выполняется приведение к базовому типу (upcasting). Далее в цикле мы печатаем информацию из каталога. Причем, для книг кроме наименования печатается еще и список авторов. Для этого с использованием операции instanceof проверяется тип печатного издания, а при самой печати списка авторов элемент каталога преобразуется к типу Book. Если этого не сделать, транслятор выдаст ошибку, т.к. метод printAuthors(. ) есть только в классе Book, но не в классе Issue.

Полиморфизм

В ООП применяется понятие полиморфизм .

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

Понятие полиморфизма, в свою очередь, опирается на два других понятия: совместное использование ( overloading ) и переопределение ( overriding ).

Рассмотрим их подробнее.

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

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

В данном примере представлено совместное использование при наследовании. Класс Derived имеет два метода f(. ). Один он наследует от класса Base, другой описан в самом классе Derived.

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

Здесь самым интересным моментом является последняя строка. В ней "a" формально имеет тип A, но фактически ссылается на объект класса B. Возникает вопрос, какой из двух совершенно одинаково описанных методов f() будет вызван. Ответ на этот вопрос — B.f().

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

Это — динамический полиморфизм методов. Он называется поздним связыванием (dynamic binding, late binding, run-time binding). В C++ соответствующий механизм называется механизмом виртуальных функций.

Рассмотрим содержательный пример использования возможностей, которые дает переопределение методов и позднее связывание. Реализуем классы Issue и Book иначе.

и переделаем фрагмент, обеспечивающий печать нашего каталога.

В классах Issue и Book вместо двух методов printName(. ) и printAuthors(. ) теперь один метод print(..). В классе Book метод print(. ) переопределяет одноименный метод класса Issue.

  • При написании метода print(. ) в Book для сокращения кода использован прием явного вызова метода базового класса с использованием ключевого слова super . Эту возможность мы рассматривали ранее.

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

Ключевое слово final (Отступление)

В Java есть ключевое слово final , используемое как описатель полей, переменных, параметров и методов.

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

final double pi = 3.14;

Описатель final в сочетании с описателем static позволяют создать константы, т.е. поля, неизменные во всей программе. Так pi логичнее было бы описать так.

static final double pi = 3.14;

Если нужно запретить переопределение (overriding) метода во всех порожденных классах, то этот метод можно описать как final.

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

Абстрактные классы

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

В классе D метод g1 — это обычный метод, g2 — абстрактный, он содержит только заголовок, но не содержит реализации.

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

Абстрактный класс не может использоваться непосредственно для порождения объектов. Для этого необходимо, используя этот класс как базовый, породить другой класс, в котором нужно определить все абстрактные методы. Тогда можно будет создавать объекты.

С другой стороны не запрещено описывать переменные абстрактного класса. Просто им нужно присваивать ссылки на объекты неабстрактных классов.

  • В этой ситуации всегда применяется upcasting.

Возвращаясь к примеру с печатными изданиями, можно отметить, что класс Issue можно было бы реализовать как абстрактный, определив но не реализовав в нем метод print(. ). Тогда во всех порожденных классах (Book, Journal, Newspaper) пришлось бы реализовать метод print(. ). Фрагмент, печатающий каталог, при этом остался бы прежним.

Интерфейсы

Понятие интерфейса чем-то похоже на абстрактный класс. Интерфейс — это полностью абстрактный класс, не содержащий никаких полей, кроме констант (static final - поля).

  • Терминология. Класс наследует другой класс, но, класс удовлетворяет интерфейсу, класс реализует, выполняет интерфейс.

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

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

Это описание интерфейса XXX. Внутри скобок могут находиться только описания методов (без реализации) и описания констант (static final — полей). В данном случае интерфейс XXX содержит, в частности метод f(. ).

Класс R реализует интерфейсы Serializable и XXX.

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

Обратите внимание, что в интерфейсе f(. ) описан без описателя public, а в классе R с описателем public. Дело в том, что все методы интерфейса по умолчанию считаются public, так что этот описатель там можно опустить. А в классе R мы обязаны его использовать явно.

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

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

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

[an error occurred while processing this directive]
[an error occurred while processing this directive] (none)

Читайте также: