Полиморфизм и его использование в программах. Основы объектно-ориентированного программирования
Привет! Это статья об одном из принципов ООП - полиморфизм.
Что такое полиморфизм
Определение полиморфизма звучит устрашающе 🙂
Полиморфизм - это возможность применения одноименных методов с одинаковыми или различными наборами параметров в одном классе или в группе классов, связанных отношением наследования.
Слово "полиморфизм " может показаться сложным - но это не так. Нужно просто разбить данное определение на части и показать на примерах, что имеется в виду. Поверьте, уже в конце статьи данное определение полиморфизма покажется Вам понятным 🙂
Полиморфизм , если перевести, - это значит "много форм". Например, актер в театре может примерять на себя много ролей - или принимать "много форм".
Так же и наш код - благодаря полиморфизму он становится более гибким, чем в языках программирования, которые не используют принципы ООП.
Так о каких формах идет речь? Давайте сначала приведем примеры и покажем, как на практике проявляется полиморфизм, а потом снова вернемся к его определению.
Как проявляется полиморфизм
Дело в том, что если бы в Java не было принципа полиморфизма , компилятор бы интерпретировал это как ошибку:
Как видите, методы на картинке отличаются значениями, которые они принимают:
- первый принимает int
- а второй принимает String
Однако, поскольку в Java используется принцип полиморфизма, компилятор не будет воспринимать это как ошибку, потому что такие методы будут считаться разными :
Называть методы одинаково - это очень удобно. Например, если у нас есть метод, который ищет корень квадратный из числа, гораздо легче запомнить одно название (например, sqrt() ), чем по одному отдельному названию на этот же метод, написанный для каждого типа:
Как видите, мы не должны придумывать отдельное название для каждого метода - а главное их запоминать! Очень удобно.
Теперь Вы можете понять, почему часто этот принцип описывают фразой:
Один интерфейс - много методов
Это предполагает, что мы можем заполнить одно название (один интерфейс), по которому мы сможем обращаться к нескольким методам.
Перегрузка методов
То, что мы показывали выше - несколько методов с одним названием и разными параметрами - называется перегрузкой . Но это был пример перегрузки метода в одном классе . Но бывает еще один случай - переопределение методов родительского класса.
Переопределение методов родителя
Когда мы наследуем какой-либо класс, мы наследуем и все его методы. Но если нам хочется изменить какой-либо из методов, который мы наследуем, мы можем всего-навсего переопределить его. Мы не обязаны, например, создавать отдельный метод с похожим названием для наших нужд, а унаследованный метод будет "мертвым грузом" лежать в нашем классе.
Именно то, что мы можем создать в классе-наследнике класс с таким же названием, как и класс, который мы унаследовали от родителя, и называется переопределением.
Пример
Представим, что у нас есть такая структура:
Вверху иерархии классов стоит класс Animal . Его наследуют три класса - Cat , Dog и Cow .
У класса "Animal" есть метод "голос" (voice). Этот метод выводит на экран сообщение "Голос". Естественно, ни собака, ни кошка не говорят "Голос" 🙂 Они гавкают и мяукают. Соответственно, Вам нужно задать другой метод для классов Cat , Dog и Cow - чтобы кошка мяукала, собака гавкала, а корова говорила "Муу".
Поэтому, в классах-наследниках мы переопределяем метод voice() , чтобы мы в консоли получали "Мяу", "Гав" и "Муу".
- Обратите внимание: перед методом, который мы переопределяем, пишем "@Override ". Это дает понять компилятору, что мы хотим переопределить метод.
Так что же такое полиморфизм
Тем не менее, полиморфизм - это принцип. Все реальные примеры, которые мы приведодили выше - это только способы реализации полиморфизма.
Давайте снова посмотрим на определение, которое мы давали в начале статьи:
Полиморфизм - возможность применения одноименных методов с одинаковыми или различными наборами параметров в одном классе или в группе классов, связанных отношением наследования.
Выглядит понятнее, правда? Мы показали, как можно:
- создавать "одноименные методы" в одном классе ("перегрузка методов")
- или изменить поведение методов родительского класса ("переопределение методов").
Все это - проявления "повышенной гибкости" объектно-ориентированных языков благодаря полиморфизму.
Надеемся, наша статья была Вам полезна. Записаться на наши курсы по Java можно у нас на .
Объектно-ориентированное программирование (ООП) – подход к созданию программ, основанный на использовании классов и объектов, взаимодействующих между собой.
Класс (java class) описывает устройство и поведение объектов. Устройство описывается через набор характеристик (свойств), а поведение – через набор доступных для объектов операций (методов). Классы можно создавать на основе уже имеющихся, добавляя или переопределяя свойства и методы.
Классы представляют шаблоны, по которым строятся объекты. Объекты – это элементы программы, обладающие схожим набором характеристик и поведением (т.е это элементы, построенные на основе одного класса). Каждый объект имеет некоторое состояние, оно определяется значением всех его свойств. В одной программе могут существовать несколько классов, а объекты разных классов могут взаимодействовать между собой (через методы).
Наследование, extends
Наследование является неотъемлемой частью Java. При использовании наследования принимается во внимание, что новый класс, наследующий свойства базового (родительского) класса имеет все те свойства, которым обладает родитель. В коде используется операнд extends , после которого указывается имя базового класса. Тем самым открывается доступ ко всем полям и методам базового класса.
Используя наследование, можно создать общий "java class", который определяет характеристики, общие для набора связанных элементов. Затем можно наследоваться от него и создать дополнительные классы, для которых определить дополнительные уникальные для них характеристики.
Главный наследуемый класс в Java называют суперклассом super . Наследующий класс называют подклассом . Таким образом подкласс - это специализированная версия суперкласса, которая наследует все свойства суперкласса и добавляет свои собственные уникальные элементы.
Рассмотрим пример описания java class"a студента Student, который имеет имя, фамилию, возраст, и номер группы. Класс студента будем создавать на основе super класса пользователя User, у которого уже определены имя, фамилия и возраст:
Public class User { int age; String firstName; String lastName; // Конструктор public User(int age, String firstName, String lastName) { this.age = age; this.firstName = firstName; this.lastName = lastName; } }
Теперь создаем отдельный класс Student, наследующего свойства super класса. При наследовании класса необходимо также переопределить и конструкторы родительского класса:
Public class Student extends User { int group; // Конструктор public Student(int age, String firstName, String lastName) { super(age, firstName, lastName); } boolean isMyGroup(int g) { return g == group; } }
Ключевое слово extends показывает, что мы наследуемся от класса User.
Ключевое слово super
В конструкторе класса Student мы вызываем конструктор родительского класса через оператор super , передавая ему весь необходимой набор параметров. В Java ключевое слово super обозначает суперкласс, т.е. класс, производным от которого является текущий класс. Ключевое слово super можно использовать для вызова конструктора суперкласса и для обращения к члену суперкласса, скрытому членом подкласса.
Рассмотрим как происходит наследование с точки зрения создания объекта:
Student student = new Student(18, "Киса", "Воробьянинов", 221);
Сначала открывается конструктор класса Student, после этого вызывается конструктор суперкласса User, а затем выполняются оставшиеся операции в конструкторе Student. Такая последовательность действий вполне логична и позволяет создавать более сложные объекты на основе более простых.
У суперкласса могут быть несколько перегруженных версий конструкторов, поэтому можно вызывать метод super() с разными параметрами. Программа выполнит тот конструктор, который соответствует указанным аргументам.
Вторая форма ключевого слова super действует подобно ключевому слову this , только при этом мы всегда ссылаемся на суперкласс подкласса, в котором она использована. Общая форма имеет следующий вид:
Здесь член может быть методом либо переменной экземпляра. Подобная форма подходит в тех случаях, когда имена членов подкласса скрывают члены суперкласса с такими же именами.
Class A { int i; } // наследуемся от класса A class B extends A { int i; // имя переменной совпадает и скрывает переменную i в классе A B(int a, int b) { super.i = a; // обращаемся к переменной i из класса A i = b; // обращаемся к переменной i из класса B } void show() { System.out.println("i из суперкласса равно " + super.i); System.out.println("i в подклассе равно " + i); } } class MainActivity { B subClass = new B(1, 2); subClass.show(); }
В результате в консоли мы должны увидеть:
I из суперкласса равно 1 i в подклассе равно 2
Переопределение методов, Override
Если в иерархии классов имя и сигнатура типа метода подкласса совпадает с атрибутами метода суперкласса, то метод подкласса переопределяет метод суперкласса. Когда переопределённый метод вызывается из своего подкласса, он всегда будет ссылаться на версию этого метода, определённую подклассом. А версия метода из суперкласса будет скрыта.
Если нужно получить доступ к версии переопределённого метода, определённого в суперклассе, то необходимо использовать ключевое слово super .
Не путайте переопределение с перегрузкой. Переопределение метода выполняется только в том случае, если имена и сигнатуры типов двух методов идентичны. В противном случае два метода являются просто перегруженными.
В Java SE5 появилась анотация @Override; . Если необходимо переопределить метод, то используйте @Override, и компилятор выдаст сообщение об ошибке, если вместо переопределения будет случайно выполнена перегрузка.
В Java можно наследоваться только от одного класса.Инкапсуляция
В информатике инкапсуляцией (лат. en capsula) называется упаковка данных и/или функций в единый объект.
Основой инкапсуляции в Java является класс. Инкапсуляция означает, что поля объекта недоступны его клиентам непосредственно - они скрываются от прямого доступа извне. Инкапсуляция предохраняет данные объекта от нежелательного доступа, позволяя объекту самому управлять доступом к своим данным.
Модификаторы доступа
При описании класса используются модификаторы доступа. Модификаторы доступа можно рассматривать как с позиции инкапсуляции так и наследования . Если рассматривать с позиции инкапсуляции, то модификаторы доступа позволяют ограничить нежелательный доступ к членам класса извне.
Открытые члены класса составляют внешнюю функциональность, которая доступна другим классам. Закрытыми (private) обычно объявляются независимые от внешнего функционала члены, а также вспомогательные методы, которые являются лишь деталями реализации и неуниверсальны по своей сути. Благодаря сокрытию реализации класса можно менять внутреннюю логику отдельного класса, не меняя код остальных компонентов системы.
Желательно использовать доступ к свойствам класса только через его методы (принцип bean классов, "POJO"), который позволяет валидировать значения полей, так как прямое обращение к свойствам отслеживать крайне сложно, а значит им могут присваиваться некорректные значения на этапе выполнения программы. Такой принцип относится к управлению инкапсулированными данными и позволяет быстро изменить способ хранения данных. Если данные станут храниться не в памяти, а в файлах или базе данных, то потребуется изменить лишь ряд методов одного класса, а не вводить эту функциональность во все части системы.
Программный код, написанный с использованием принципа инкапсуляции легче отлаживать. Для того чтобы узнать, в какой момент времени и кто изменил свойство интересующего нас объекта, достаточно добавить вывод отладочной информации в тот метод объекта, посредством которого осуществляется доступ к свойству этого объекта. При использовании прямого доступа к свойствам объектов программисту бы пришлось добавлять вывод отладочной информации во все участки кода, где используется интересующий нас объект.
Пример простого описания робота
Public class Robot { private double x = 0; // Текущая координата X private double y = 0; // Текущая координата Y private double course = 0; // Текущий курс (в градусах) public double getX() { return x; } public void setX(double x) { this.x = x; } public double getY() { return y; } public void setY(double y) { this.y = y; } public double getCourse() { return course; } // Определение курса public void setCourse(double course) { this.course = course; } // Передвижение на дистанцию distance public void forward(int distance) { // Обращение к полю объекта X x = x + distance * Math.cos(course / 180 * Math.PI); // Обращение к полю объекта Y y = y + distance * Math.sin(course / 180 * Math.PI); } // Печать координат робота public void printCoordinates() { System.out.println(x + "," + y); } }
В представленном примере робота используются наборы методов, начинающие с set и get . Эту пару методов часто называют сеттер/геттер. Данные методы используются для доступа к полям объекта. Наименования метода заканчиваются наименованием поля, начинающееся с ПРОПИСНОЙ буквы.
В методах set мы передаем значение через формальный параметр во внутрь процедуры. В коде процедуры мы присваиваем значение переменной объекта/класса с использованием ключевого слова this .
This.course = course ...
Использование ключевого слова this необходимо, т.к. наименование формального параметра совпадает с наименованием переменной объекта. Если бы наименования отличались бы, то можно было бы this не использавать.
Полиморфизм, polymorphism
Полиморфизм является одним из фундаментальных понятий в объектно-ориентированном программировании наряду с наследованием и инкапсуляцией. Слово полиморфизм греческого происхождения и означает "имеющий много форм". Чтобы понять, что означает полиморфизм применительно к объектно-ориентированному программированию, рассмотрим пример создания векторного графического редактора, в котором необходимо использовать ряд классов в виде набора графических примитивов - Square , Line , Circle , Triangle , и т.д. У каждого из этих классов необходимо определить метод draw для отображения соответствующего примитива на экране.
Очевидно, придется написать некоторый код, который для изображения рисунка будет последовательно перебирать все примитивы, которые необходимо вывести на экран, и вызывать метод draw у каждого из них.
Человек, незнакомый с полиморфизмом, вероятнее всего создаст несколько массивов: отдельный массив для каждого типа примитивов и напишет код, который последовательно переберет элементы из каждого массива и вызовет у каждого элемента метод draw. В результате получится примерно следующий код:
// Определение массивов графических примитивов Square s = new Square ; Line l = new Line ; Circle c = new Circle ; Triangle t = new Triangle; // Заполнение всех массивов соответствующими объектами. . . // Цикл с перебором всех ячеек массива. for (int i = 0; i < s.length; i++){ // вызов метода draw() в случае, если ячейка не пустая. if (s[i] != null) s.draw(); } for(int i = 0; i < l.length; i++){ if (l[i] != null) l.draw(); } for(int i = 0; i < c.length; i++){ if (c[i] != null) c.draw(); } for(int i = 0; i < t.length; i++){ if (t[i] != null) t.draw(); }
Недостатком написанного выше кода является дублирование практически идентичного кода для отображения каждого типа примитивов. Также неудобно то, что при дальнейшей модернизации нашего графического редактора и добавлении возможности рисовать новые типы графических примитивов, например Text, Star и т.д., при таком подходе придется менять уже существующий код и добавлять в него определения новых массивов, а также обработку элементов, содержащихся в них.
Используя полиморфизм, можно значительно упростить реализацию подобной функциональности. Прежде всего, создадим общий родительский класс Shape для всех наших классов.
Public class Shape { public void draw() { System.out.println("Заглушка"); } }
После этого мы создаем различные классы-наследники: Square (Квадрат), Line (Линия), Сircle (круг) и Triangle (Треугольник):
Public class Point extends Shape { public void draw() { System.out.println("Квадрат"); } } public class Line extends Shape { public void draw() { System.out.println("Линия"); } } public class Сircle extends Shape { public void draw() { System.out.println("Круг"); } } public class Triangle extends Shape { public void draw() { System.out.println("Треугольник"); } }
В наследниках у нас переопределен метод draw. В результате получили иерархию классов, которая изображена на рисунке.
Теперь проверим удивительную возможность полиморфизма:
// Определение и инициализация массива Shape a = new Shape {new Shape(), new Triangle(), new Square(), new Сircle()}; // Перебор в цикле элементов массива for(int i = 0; i < a.length; i++) { a[i].draw(); }
В консоль будут выведены следующие строки:
Заглушка Треугольник Квадрат Круг
Таким образом каждый класс-наследник вызвал именно свой метод draw, вместо того, чтобы вызвать метод draw из родительского класса Shape.
Полиморфизм - положение теории типов, согласно которому имена (например, переменных) могут обозначать объекты разных, но имеющих общего родителя, классов. Следовательно, любой объект, обозначаемый полиморфным именем, может посвоему реагировать на некий общий набор операций.
Перегрузка метода, overload
В процедурном программировании тоже существует понятие полиморфизма, которое отличается от рассмотренного механизма в ООП. Процедурный полиморфизм предполагает возможность создания нескольких процедур или функций с одинаковым именем, но разными количеством или типами передаваемых параметров. Такие одноименные функции называются перегруженными, а само явление - перегрузкой (overload). Перегрузка функций существует и в ООП и называется перегрузкой методов. Примером использования перегрузки методов в языке Java может служить класс PrintWriter , который используется в частности для вывода сообщений на консоль. Этот класс имеет множество методов println, которые различаются типами и/или количеством входных параметров. Вот лишь несколько из них:
Void println() // переход на новую строку void println(boolean x) // выводит значение булевской переменной (true или false) void println(String x) // выводит строку - значение текстового параметра
s_a_p 20 августа 2008 в 19:09
Полиморфизм для начинающих
- PHP
Полиморфизм — одна из трех основных парадигм ООП. Если говорить кратко, полиморфизм — это способность обьекта использовать методы производного класса, который не существует на момент создания базового. Для тех, кто не особо сведущ в ООП, это, наверно, звучит сложно. Поэтому рассмотрим применение полиморфизма на примере.
Постановка задачи
Предположим, на сайте нужны три вида публикаций — новости, объявления и статьи. В чем-то они похожи — у всех них есть заголовок и текст, у новостей и объявлений есть дата. В чем-то они разные — у статей есть авторы, у новостей — источники, а у объявлений — дата, после которой оно становится не актуальным.Самые простые варианты, которые приходят в голову — написать три отдельных класса и работать с ними. Или написать один класс, в которым будут все свойства, присущие всем трем типам публикаций, а задействоваться будут только нужные. Но ведь для разных типов аналогичные по логике методы должны работать по-разному. Делать несколько однотипных методов для разных типов (get_news, get_announcements, get_articles) — это уже совсем неграмотно. Тут нам и поможет полиморфизм.
Абстрактный класс
Грубо говоря, это класс-шаблон. Он реализует функциональность только на том уровне, на котором она известна на данный момент. Производные же классы ее дополняют. Но, пора перейти от теории к практике. Сразу оговорюсь, рассматривается примитивный пример с минимальной функциональностью. Все объяснения — в комментариях в коде.abstract class
Publication
{
// таблица, в которой хранятся данные по элементу
protected
$table
;
// свойства элемента нам неизвестны
protected
$properties
= array();
// конструктор
{
// обратите внимание, мы не знаем, из какой таблицы нам нужно получить данные
$result
=
mysql_query
("SELECT * FROM `"
.
$this
->
table
.
"` WHERE `id`=""
.
$id
.
"" LIMIT 1"
);
// какие мы получили данные, мы тоже не знаем
$this
->
properties
=
mysql_fetch_assoc
($result
);
}
// метод, одинаковый для любого типа публикаций, возвращает значение свойства
public function
get_property
($name
)
{
if (isset($this
->
properties
[
$name
]))
return
$this
->
properties
[
$name
];
Return
false
;
}
// метод, одинаковый для любого типа публикаций, устанавливает значение свойства
public function
set_property
($name
,
$value
)
{
if (!isset($this
->
properties
[
$name
]))
return
false
;
$this -> properties [ $name ] = $value ;
Return
$value
;
}
// а этот метод должен напечатать публикацию, но мы не знаем, как именно это сделать, и потому объявляем его абстрактным
abstract public function
do_print
();
}
Производные классы
Теперь можно перейти к созданию производных классов, которые и реализуют недостающую функциональность.class
News
extends
Publication
{
// конструктор класса новостей, производного от класса публикаций
public function
__construct
($id
)
{
// устанавливаем значение таблицы, в которой хранятся данные по новостям
$this
->
table
=
"news_table"
;
parent
::
__construct
($id
);
}
Public function
do_print
()
{
echo
$this
->
properties
[
"title"
];
echo
"
"
;
echo
$this
->
properties
[
"text"
];
echo
"
Источник: "
.
$this
->
properties
[
"source"
];
}
}
Class
Announcement
extends
Publication
{
// конструктор класса объявлений, производного от класса публикаций
public function
__construct
($id
)
{
// устанавливаем значение таблицы, в которой хранятся данные по объявлениям
$this
->
table
=
"announcements_table"
;
// вызываем конструктор родительского класса
parent
::
__construct
($id
);
}
// переопределяем абстрактный метод печати
public function
do_print
()
{
echo
$this
->
properties
[
"title"
];
echo
"
Внимание! Объявление действительно до "
.
$this
->
properties
[
"end_date"
];
echo
"
"
.
$this
->
properties
[
"text"
];
}
}
Class
Article
extends
Publication
{
// конструктор класса статей, производного от класса публикаций
public function
__construct
($id
)
{
// устанавливаем значение таблицы, в которой хранятся данные по статьям
$this
->
table
=
"articles_table"
;
// вызываем конструктор родительского класса
parent
::
__construct
($id
);
}
// переопределяем абстрактный метод печати
public function
do_print
()
{
echo
$this
->
properties
[
"title"
];
echo
"
"
;
echo
$this
->
properties
[
"text"
];
echo
"
"
.
$this
->
properties
[
"author"
];
}
}
Теперь об использовании
Суть в том, что один и тот же код используется для обьектов разных классов.// наполняем массив публикаций объектами, производными от Publication
$publications
= new
News
($news_id
);
$publications
= new
Announcement
($announcement_id
);
$publications
= new
Article
($article_id
);
Foreach ($publications
as
$publication
) {
// если мы работаем с наследниками Publication
if ($publication
instanceof
Publication
) {
// то печатаем данные
$publication
->
do_print
();
} else {
// исключение или обработка ошибки
}
}
Вот и все. Легким движением руки брюки превращаются в элегантные шорты:-).
Основная выгода полиморфизма — легкость, с которой можно создавать новые классы, «ведущие себя» аналогично родственным, что, в свою очередь, позволяет достигнуть расширяемости и модифицируемости. В статье показан всего лишь примитивный пример, но даже в нем видно, насколько использование абстракций может облегчить разработку. Мы можем работать с новостями точно так, как с объявлениями или статьями, при этом нам даже не обязательно знать, с чем именно мы работаем! В реальных, намного более сложных приложениях, эта выгода еще ощутимей.
Немного теории
- Методы, которые требуют переопределения, называются абстрактными. Логично, что если класс содержит хотя бы один абстрактный метод, то он тоже является абстрактным.
- Очевидно, что обьект абстрактного класса невозможно создать, иначе он не был бы абстрактным.
- Производный класс имеет свойства и методы, принадлежащие базовому классу, и, кроме того, может иметь собственные методы и свойства.
- Метод, переопределяемый в производном классе, называется виртуальным. В базовом абстрактном классе об этом методе нет никакой информации.
- Суть абстрагирования в том, чтобы определять метод в том месте, где есть наиболее полная информация о том, как он должен работать.
Объединение объектов в классы позволяет рассмотреть задачу в более общей постановке. Класс имеет имя (например, "лошадь"), которое относится ко всем объектам этого класса . Кроме того, в классе вводятся имена атрибутов, которые определены для объектов . В этом смысле описание класса аналогично описанию типа структуры или записи ( record ), широко применяющихся в процедурном программировании; при этом каждый объект имеет тот же смысл, что и экземпляр структуры ( переменная или константа соответствующего типа).
Формально класс - это шаблон поведения объектов определенного типа с заданными параметрами, определяющими состояние . Все экземпляры одного класса (объекты , порожденные от одного класса ) имеют один и тот же набор свойств и общее поведение , то есть одинаково реагируют на одинаковые сообщения.
В соответствии с UML ( Unified Modelling Language - унифицированный язык моделирования ), класс имеет следующее графическое представление .
Класс изображается в виде прямоугольника, состоящего из трех частей. В верхней части помещается название класса , в средней - свойства объектов класса , в нижней - действия, которые можно выполнять с объектами данного класса (методы).
Каждый класс также может иметь специальные методы, которые автоматически вызываются при создании и уничтожении объектов этого класса :
- конструктор (constructor) - выполняется при создании объектов ;
- деструктор ( destructor ) - выполняется при уничтожении объектов .
Обычно конструктор и деструктор имеют специальный синтаксис , который может отличаться от синтаксиса, используемого для написания обычных методов класса .
Инкапсуляция
Инкапсуляция (encapsulation) - это сокрытие реализации класса и отделение его внутреннего представления от внешнего (интерфейса). При использовании объектно-ориентированного подхода не принято применять прямой доступ к свойствам какого-либо класса из методов других классов . Для доступа к свойствам класса принято задействовать специальные методы этого класса для получения и изменения его свойств.
Внутри объекта данные и методы могут обладать различной степенью открытости (или доступности). Степени доступности, принятые в языке Java, подробно будут рассмотрены в лекции 6. Они позволяют более тонко управлять свойством инкапсуляции .
Открытые члены класса составляют внешний интерфейс объекта . Это та функциональность, которая доступна другим классам . Закрытыми обычно объявляются все свойства класса , а также вспомогательные методы, которые являются деталями реализации и от которых не должны зависеть другие части системы.
Благодаря сокрытию реализации за внешним интерфейсом класса можно менять внутреннюю логику отдельного класса , не меняя код остальных компонентов системы. Это свойство называется модульность .
Обеспечение доступа к свойствам класса только через его методы также дает ряд преимуществ. Во-первых, так гораздо проще контролировать корректные значения полей, ведь прямое обращение к свойствам отслеживать невозможно, а значит, им могут присвоить некорректные значения.
Во-вторых, не составит труда изменить способ хранения данных. Если информация станет храниться не в памяти, а в долговременном хранилище, таком как файловая система или база данных, потребуется изменить лишь ряд методов одного класса , а не вводить эту функциональность во все части системы.
Наконец, программный код, написанный с использованием данного принципа, легче отлаживать. Для того чтобы узнать, кто и когда изменил свойство интересующего нас объекта , достаточно добавить вывод отладочной информации в тот метод объекта , посредством которого осуществляется доступ к свойству этого объекта . При использовании прямого доступа к свойствам объектов программисту пришлось бы добавлять вывод отладочной информации во все участки кода, где используется интересующий нас объект .
Наследование
Наследование (inheritance) - это отношение между классами , при котором класс использует структуру или поведение другого класса (одиночное наследование ), или других (множественное наследование ) классов . Наследование вводит иерархию "общее/частное", в которой подкласс наследует от одного или нескольких более общих суперклассов . Подклассы обычно дополняют или переопределяют унаследованную структуру и поведение .
В качестве примера можно рассмотреть задачу, в которой необходимо реализовать классы "Легковой автомобиль" и "Грузовой автомобиль". Очевидно, эти два класса имеют общую функциональность. Так, оба они имеют 4 колеса, двигатель, могут перемещаться и т.д. Всеми этими свойствами обладает любой автомобиль, независимо от того, грузовой он или легковой, 5- или 12-местный. Разумно вынести эти общие свойства и функциональность в отдельный класс , например, "Автомобиль" и наследовать от него классы "Легковой автомобиль" и "Грузовой автомобиль", чтобы избежать повторного написания одного и того же кода в разных классах .
Отношение обобщения обозначается сплошной линией с треугольной стрелкой на конце. Стрелка указывает на более общий класс ( класс-предок или суперкласс ), а ее отсутствие - на более специальный класс ( класс-потомок или подкласс ).
Использование наследования способствует уменьшению количества кода, созданного для описания схожих сущностей, а также способствует написанию более эффективного и гибкого кода.
В рассмотренном примере применено одиночное наследование . Некоторый класс также может наследовать свойства и поведение сразу нескольких классов . Наиболее популярным примером применения множественного наследования является проектирование системы учета товаров в зоомагазине.
Все животные в зоомагазине являются наследниками класса "Животное", а также наследниками класса "Товар". Т.е. все они имеют возраст, нуждаются в пище и воде и в то же время имеют цену и могут быть проданы.
Множественное наследование на диаграмме изображается точно так же, как одиночное, за исключением того, что линии наследования соединяют класс-потомок сразу с несколькими суперклассами .
Не все объектно-ориентированные языки программирования содержат языковые конструкции для описания множественного наследования .
В языке Java множественное наследование имеет ограниченную поддержку через интерфейсы и будет рассмотрено в лекции 8.
Полиморфизм
Полиморфизм является одним из фундаментальных понятий в объектно-ориентированном программировании наряду с наследованием и инкапсуляцией . Слово " полиморфизм " греческого происхождения и означает "имеющий много форм". Чтобы понять, что оно означает применительно к объектно-ориентированному программированию , рассмотрим пример.
Предположим, мы хотим создать векторный графический редактор, в котором нам нужно описать в виде классов набор графических примитивов - Point , Line , Circle , Box и т.д. У каждого из этих классов определим метод draw для отображения соответствующего примитива на экране.
Очевидно, придется написать код, который при необходимости отобразить рисунок, будет последовательно перебирать все примитивы, на момент отрисовки находящиеся на экране, и вызывать метод draw у каждого из них. Человек, не знакомый с полиморфизмом , вероятнее всего, создаст несколько массивов (отдельный массив для каждого типа примитивов) и напишет код, который последовательно переберет элементы из каждого массива и вызовет у каждого элемента метод draw . В результате получится примерно следующий код:
... //создание пустого массива, который может // содержать объекты Point с максимальным // объемом 1000 Point p = new Point; Line l = new Line; Circle c = new Circle; Box b = new Box; ... // предположим, в этом месте происходит // заполнение всех массивов соответствующими // объектами... for(int i = 0; i < p.length;i++) { //цикл с перебором всех ячеек массива. //вызов метода draw() в случае, // если ячейка не пустая. if(p[i]!=null) p[i].draw(); } for(int i = 0; i < l.length;i++) { if(l[i]!=null) l[i].draw(); } for(int i = 0; i < c.length;i++) { if(c[i]!=null) c[i].draw(); } for(int i = 0; i < b.length;i++) { if(b[i]!=null) b[i].draw(); } ...
Недостатком написанного выше кода является дублирование практически идентичного кода для отображения каждого типа примитивов. Также неудобно то, что при дальнейшей модернизации нашего графического редактора и добавлении возможности рисовать новые типы графических примитивов, например Text , Star и т.д., при таком подходе придется менять существующий код и добавлять в него определения новых массивов, а также обработку содержащихся в них элементов.
Используя полиморфизм , мы можем значительно упростить реализацию подобной функциональности. Прежде всего, создадим общий родительский
Лекция в виде презентации в формате pdf с примерами - 27 слайдов.
ВолгГТУ, кафедра ПОАС, - 2010 год
В лекции рассмотрены все формы полиморфизма функций и методов т представлена их иерархия в виде схемы.
Фрагменты из лекции
Понятие полиморфизма
- Полиморфизм в языке программирования означает многозначность переменных и функций
- Полиморфной функцией является такая функция, которая может вызываться с аргументами различного типа, а фактический выполняемый код зависит от типа аргументов
Преимущества использования полиморфизма
- Полиморфизм позволяет записывать алгоритмы лишь однажды и затем повторно их использовать для различных типов данных, которые, возможно, еще не существуют (обобщенные действия или алгоритмы)
- Полиморфизм сужает концептуальное пространство, т.е. уменьшает количество информации, которое необходимо помнить программисту
Параметризованный полиморфизм
- Обеспечивается за счет так называемых обобщенных функций, которые в языке Си++ называются шаблонами
- Аргументом обобщенной функции является тип, который используется при ее параметризации
- С помощью механизма шаблонов можно создать функцию, которая бы работала с разнотипными аргументами
- Примером таких функций являются обобщенные алгоритмы из STL
Чистый полиморфизм
- Чистый полиморфизм имеет место, когда одна и та же функция применяется к аргументам различных типов
- В случае чистого полиморфизма имеется одна функция (тело кода) и несколько ее интерпретаций
- Реализация чистого полиморфизма возможна только при наличии полиморфных переменных, а точнее полиморфных аргументов
- Чистый полиморфизм позволяет реализовывать обобщенные алгоритмы
Перегрузка или полиморфизм ad hoc
- Перегрузка возникает, когда имеется два или более кода, связанных с одним именем
- Главное назначение перегрузки − сужение концептуального пространства
Перегрузка методов в несвязанных классах
- Все ОО-языки разрешают использовать методы с одинаковыми именами в несвязанных между собою классах − это перегрузка методов
- В этом случае привязка перегруженного имени производится за счет информации о классе, к которому относится получатель сообщения
Параметрическая перегрузка
- Стиль перегрузки, при котором функциям и методам в одном и том же контексте разрешается использовать совместно одно имя, а двусмысленность снимается за счет анализа числа и типов аргументов, называется параметрической перегрузкой.
Замещение методов
- Замещение возникает, когда в базовом и производном классах имеются два метода с одинаковым именем и параметрами
- В этом случае метод базового класса перекрывается методом производного класса с точки зрения пользователя класса
Назначение механизма замещения методов
- Замещение происходит прозрачно (незаметно) для пользователя класса, и, как в случае перегрузки, два метода представляются семантически как одна сущность
- Главное назначение замещения методов − сужение концептуального пространства
Пример замещения метода
Class MyEllipse
{
public:
float area() const
};
{
public:
float area() const
{//использ. более эффективный алгоритм расчета
}
};
MyEllipse ellipse;
MyCircle circle;
// Будет вызван метод MyEllipse::area()
ellipse.print();
// ВНИМАНИЕ!!! Будет вызван метод MyEllipse::area()
circle.print();
Переопределение методов
- При замещении метод базового класса перекрывается методом производного класса только снаружи. Внутри класса вызывается метод базового класса (см. предыдущий пример)
- Переопределение метода возникает, когда метод производного класса подменяет метод базового класса не только снаружи, но и внутри класса
- В языке Си++ для переопределения метода необходимо использовать механизм динамического связывания, т.е. объявить метод виртуальным
Пример переопределения метода
Class MyEllipse
{
public:
virtual float area() const
{ /* численный метод расчета */ }
void print() { printf("area = %f\n", area()); }
};
class MyCircle: public MyEllipse
{
public:
float area() const
{ //использ. более эффективн. алгоритм расчета
return 3.14*Radius1*Radius2;
}
};
MyEllipse ellipse;
MyCircle circle;
// Будет вызван метод MyEllipse::area()
printf("Ellipse area= %f\n", ellipse.area());
// Будет вызван метод MyEllipse::area()
ellipse.print();
// Будет вызван метод MyCircle::area()
printf("Circle area= %f\n", circle.area());
// ВНИМАНИЕ!!! Будет вызван метод MyCircle::area()
circle.print();
Назначение механизма переопределения методов
- Наличие механизма переопределения методов позволяет реализовать в базовом классе общую часть поведения, подразумевая, что отдельные действия будут доопределены (переопределены) в производных классах
- Таким образом, главное назначение механизма переопределения методов - сокращение объема программы
Отложенные методы
- Отложенный метод − это частный случай переопределения, когда метод базового класса не имеет реализации, а любая полезная деятельность задается в методе дочернего класса
Отложенные методы в языке Си++
- В языке Си++ отложенный метод должен быть описан в явном виде с ключевым словом virtual
- Тело отложенного метода не определяется, вместо этого функции «приписывается» значение 0
