ФЕДЕРАЛЬНОЕ ГОСУДАРСТВЕННОЕ БЮДЖЕТНОЕ
ОБРАЗОВАТЕЛЬНОЕ УЧРЕЖДЕНИЕ
ВЫСШЕГО ОБРАЗОВАНИЯ
«МОРДОВСКИЙ ГОСУДАРСТВЕННЫЙ ПЕДАГОГИЧЕСКИЙ ИНСТИТУТ
ИМЕНИ М. Е. ЕВСЕВЬЕВА»
Физико-математический факультет
Кафедра информатики и вычислительной техники
РЕФЕРАТ
КЛАССЫ. ИНКАПСУЛЯЦИЯ. НАСЛЕДОВАНИЕ
Выполнил:
студент группы МДИ-117
Рыбаков В.В.
Содержание
Введение 3
Объектно–ориентированное программирование 4
Классы 6
Инкапсуляция 8
Наследование 10
Заключение 14
Список использованной литературы 19
Введение
В данной были рассмотрены ключевые понятия ООП – объект и класс. Далее были описаны основные свойства объектной модели – инкапсуляция, наследование.
Объектно — ориентированное программирование (ООП) – методология программирования, основанная на представлении программы в виде совокупности объектов, каждый из которых является экземпляром определённого класса, а классы образуют иерархию наследования. Состоит из:
Инкапсуляции
Наследования
Полиморфизма
Инкапсуляция для быстрой и безопасной организации собственно иерархической управляемости: чтобы защитить дынные. Для этого надо: помечать переменные экземпляра как private, а геттеры и сеттеры public или protected.
Формально класс – это шаблон поведения объектов определенного типа с заданными параметрами, определяющими состояние. Все экземпляры одного класса (объекты, порожденные от одного класса) имеют один и тот же набор свойств и общее поведение, то есть одинаково реагируют на одинаковые сообщения.
Наследование для быстрой и безопасной организации родственных понятий: чтобы было достаточно на каждом иерархическом шаге учитывать только изменения, не дублируя всё остальное, учтённое на предыдущих шагах; Представить это довольно легко. Например у вас есть класс Поезд, он наследуется от класса Сухопутный транспорт, а тот в свою очередь наследуется от класса Транспортное средство. Это позволяет не создавать каждый раз одни и те же переменные экземпляра.
Объектно–ориентированное программирование
Объектно–ориентированное программирование (в дальнейшем ООП) – парадигма программирования, в которой основными концепциями являются понятия объектов и классов.
В объектно–ориентированном программировании (ООП) любая программа создается как совокупность взаимодействующих объектов. Шаблоны, на основе которых строятся объекты, называются классами. Согласно первому принципу ООП – инкапсуляции в классе определяются данные и действия, выполняемые над этими данными.
Классы, как правило, образуют иерархию. Второй принцип ООП –наследование позволяет создать общий класс, который может быть унаследован другими, более специализированными классами. И, наконец, третий принцип ООП – полиморфизм означает, что методы с одним и тем же именем могут иметь разный код.
В центре ООП находится понятие объекта.
Объект – это сущность, экземпляр класса, которой можно посылать сообщения и которая может на них реагировать, используя свои данные. Данные объекта скрыты от остальной программы. Сокрытие данных называется инкапсуляцией.
Наличие инкапсуляции достаточно для объективности языка программирования, но ещё не означает его объектной ориентированности – для этого требуется наличие наследования.
Но даже наличие инкапсуляции и наследования не делает язык программирования в полной мере объектным с точки зрения ООП. Основные преимущества ООП проявляются только в том случае, когда в языке программирования реализован полиморфизм, то есть возможность объектов с одинаковой спецификацией иметь различную реализацию.
Хочу выделить что очень часто натыкаюсь на мнение, что в ООП стоит выделять еще одну немаловажную характеристику – абстракцию. Официально её не вносили в обязательные черты ООП, но списывать ее со счетов не стоит.
Абстрагирование – это способ выделить набор значимых характеристик объекта, исключая из рассмотрения не значимые. Соответственно, абстракция – это набор всех таких характеристик.
Инкапсуляция – это свойство системы, позволяющее объединить данные и методы, работающие с ними в классе, и скрыть детали реализации от пользователя.
Наследование – это свойство системы, позволяющее описать новый класс на основе уже существующего с частично или полностью заимствующейся функциональностью. Класс, от которого производится наследование, называется базовым, родительским или суперклассом. Новый класс – потомком, наследником или производным классом
Полиморфизм – это свойство системы использовать объекты с одинаковым интерфейсом без информации о типе и внутренней структуре объекта.
То есть фактически речь идёт о прогрессирующей организации информации согласно первичным семантическим критериям: «важное/неважное», «ключевое/подробности», «родительское/дочернее», «единое/множественное». Прогрессирование, в частности, на последнем этапе даёт возможность перехода на следующий уровень детализации, что замыкает общий процесс.
Обычный человеческий язык в целом отражает идеологию ООП, начиная с инкапсуляции представления о предмете в виде его имени и заканчивая полиморфизмом использования слова в переносном смысле, что в итоге развивает выражение представления через имя предмета до полноценного понятия–класса.
Классы
Классы и объекты – базовые понятия объектно–ориентированного программирования. В первой главе эти понятия были рассмотрены очень кратко.
Класс – описание множества объектов, имеющих одинаковые атрибуты и поведение.
Поскольку класс определяется как описание данных вместе с множеством действий, которые выполняются над этими данными, можно дать еще одно определение класса.
Класс – абстрактный тип, на основе которого создаются объекты.
Фактически класс – образец (шаблон) для создания объектов.
Класс должен определять одну логическую сущность, т. е. содержать логически связанные данные. Например, класс, в котором хранится информация о сотруднике предприятия, и должен содержать сведения о погоде или урожае.
Описание класса включает:
имя класса;
описание атрибутов (полей);
описание методов (кода, обрабатывающего эти поля).
описание атрибутов (полей);
описание методов (кода, обрабатывающего эти поля)
Классы могут включать только методы или только поля. Полян методы называют элементами класса. Кроме того, классе может определить и ряд других элементов.
Описание класса, содержащего только поля и методы
Class ИМЯ_КЛАССА {
ОПИСАНИЕ ПОЛЕЙ
ОПИСАНИЕ МЕТОДОВ
}
Поля класса синтаксически являются переменными, а методы – функциями.
Уточненный вариант описания класса:
Class ИМЯ_КЛАССА {
//описание полей
ДОСТУП ТИП ПЕРЕМЕННАЯ_1;
ДОСТУП ТИП ПЕРЕМЕННАЯ_2;
…
ДОСТУП ТИП ПЕРЕМЕННАЯ_N;
// описание методов
ДОСТУП ТИП_ВОЗВР_ЗНАЧЕНИЯ ИМЯ_МЕТОД1
(ФОРМАЛЬНЫЕ ПАРАМЕТРЫ)
{ ТЕЛО МЕТОДА }
ДОСТУП_ТИП_ВОЗВР_ЗНАЧЕНИЯ ИМЯ_МЕТОД_2
(ФОРМАЛЬНЫЕ ПАРАМЕТРЫ)
{ ТЕЛО МЕТОДА}
…
ДОСТУП ТИП_ВОЗВР_ЗНАЧЕНИЯ ИМЯ_МЕТОД_N
(ФОРМАЛЬНЫЕ ПАРАМЕТРЫ)
{ ТЕЛО МЕТОДА}
}
Спецификатор доступа ДОСТУП определяет способ получения доступа к элементу класса.
Элементы с доступом private (принят по умолчанию) могут
Использовать только другими элементами этого же класса. Элементы с доступом public могу использоваться в любых частях программы.
Пример. Описание класса, содержащего только поля
Описать класс «Компания»
Поля касса:
Название, количество сотрудников, месячный фонд зарплаты
class Company {
public string name; //название компании
public int persons; //количество сотрудников
public int money;// месячный фонд зарплаты
}
Инкапсуляция
Инкапсуляция – свойство языка программирования, позволяющее пользователю не задумываться о сложности реализации используемого программного компонента (что у него внутри?), а взаимодействовать с ним посредством предоставляемого интерфейса (публичных методов и членов), а также объединить и защитить жизненно важные для компонента данные. При этом пользователю предоставляется только спецификация (интерфейс) объекта.
Инкапсуляция – один из четырёх важнейших механизмов объектно–ориентированного программирования (наряду с абстракцией, полиморфизмом и наследованием).
Сокрытие реализации целесообразно применять в следующих случаях:
предельная локализация изменений при необходимости таких изменений,
прогнозируемость изменений (какие изменения в коде надо сделать для заданного изменения функциональности) и прогнозируемость последствий изменений.
Инкапсуляция позволит скрыть детали реализации, и открыть только то что необходимо в последующем использовании. Другими словами, инкапсуляция – это механизм контроля доступа.
Цель инкапсуляции – уйти от зависимости внешнего интерфейса класса (то, что могут использовать другие классы) от реализации. Чтобы малейшее изменение в классе не влекло за собой изменение внешнего поведения класса. Давайте рассмотрим, как ею пользоваться.
Существует 4 вида модификаторов доступа: public, protected, private и default.
Public – уровень предполагает доступ к компоненту с этим модификатором из экземпляра любого класса и любого пакета.
Protected – уровень предполагает доступ к компоненту с этим модификатором из экземпляров родного класса и классов–потомков, независимо от того, в каком пакете они находятся.
Default – уровень предполагает доступ к компоненту с этим модификатором из экземпляров любых классов, находящихся в одном пакете с этим классом.
Private – уровень предполагает доступ к компоненту с этим модификатором только из этого класса.
public class Human {
public String name;
protected String surname;
private int age;
int birthdayYear;
}
public String name; – имя, которое доступное из любого места в приложении.
protected String surname; – фамилия доступна из родного класса и потомков.
private int age; – возраст доступен только в рамках класса Human.
int birthdayYear; – хоть не указывается явный модификатор доступа, система понимает его как default, год рождения будет доступен всему пакету, в котором находится класс Human.
Для разных структурных элементов класса предусмотрена возможность применять только определенные уровни модификаторов доступа.
Для класса – только public и default.
Для атрибутов класса – все 4 вида.
Для конструкторов – все 4 вида.
Для методов – все 4 вида.
Наследование
Наследование – один из четырёх важнейших механизмов объектно — ориентированного программирования (наряду с инкапсуляцией, полиморфизмом и абстракцией), позволяющий описать новый класс на основе уже существующего (родительского), при этом свойства и функциональность родительского класса заимствуются новым классом.
Другими словами, класс-наследник реализует спецификацию уже существующего класса (базовый класс). Это позволяет обращаться с объектами класса-наследника точно так же, как с объектами базового класса.
Простое наследование. Класс, от которого произошло наследование, называется базовым или родительским (англ. base class). Классы, которые произошли от базового, называются потомками, наследниками или производными классами (англ. derived class).
В некоторых языках используются абстрактные классы. Абстрактный класс – это класс, содержащий хотя бы один абстрактный метод, он описан в программе, имеет поля, методы и не может использоваться для непосредственного создания объекта. То есть от абстрактного класса можно только наследовать. Объекты создаются только на основе производных классов, наследованных от абстрактного. Например, абстрактным классом может быть базовый класс «сотрудник вуза», от которого наследуются классы «аспирант», «профессор» и т. д. Так как производные классы имеют общие поля и функции (например, поле «год рождения»), то эти члены класса могут быть описаны в базовом классе. В программе создаются объекты на основе классов «аспирант», «профессор», но нет смысла создавать объект на основе класса «сотрудник вуза».
Множественное наследование. При множественном наследовании у класса может быть более одного предка. В этом случае класс наследует методы всех предков. Достоинства такого подхода в большей гибкости. Множественное наследование реализовано в C++. Из других языков, предоставляющих эту возможность, можно отметить Python и Эйфель. Множественное наследование поддерживается в языке UML.
Множественное наследование – потенциальный источник ошибок, которые могут возникнуть из-за наличия одинаковых имен методов в предках. В языках, которые позиционируются как наследники C++ (Java, C# и др.), от множественного наследования было решено отказаться в пользу интерфейсов. Практически всегда можно обойтись без использования данного механизма. Однако, если такая необходимость все-таки возникла, то, для разрешения конфликтов использования наследованных методов с одинаковыми именами, возможно, например, применить операцию расширения видимости – «::» – для вызова конкретного метода конкретного родителя.
Попытка решения проблемы наличия одинаковых имен методов в предках была предпринята в языке Эйфель, в котором при описании нового класса необходимо явно указывать импортируемые члены каждого из наследуемых классов и их именование в дочернем классе.
Большинство современных объектно-ориентированных языков программирования (C#, Java, Delphi и др.) поддерживают возможность одновременно наследоваться от класса-предка и реализовать методы нескольких интерфейсов одним и тем же классом. Этот механизм позволяет во многом заменить множественное наследование – методы интерфейсов необходимо переопределять явно, что исключает ошибки при наследовании функциональности одинаковых методов различных классов–предков.
Наследование является важным, поскольку оно позволяет поддерживать концепцию иерархии классов (hierarchical classification). Применение иерархии классов делает управляемыми большие потоки информации.
Разберем этот механизм на классическом примере: Геометрические фигуры.
У нас есть интерфейс Figure:
public interface Figure {
public void draw ();
public void erase ();
public void move ();
public String getColor ();
public boolean setColor ();
}
Интерфейс (более детально будут рассмотрены в скором будущем) – нам говорит, как должен выглядеть класс, какие методы в себе содержать, какими переменными и типами данных манипулировать. Сам интерфейс не реализует методы, а создает как бы скелет для класса, который будет расширять этот интерфейс. Есть класс Figure, который расширяет интерфейс Figure. В этом классе мы реализуем все методы интерфейса Figure.
public class Figure implements devcolibri. Com .oop .inheritance .interfaces. Figure – с помощью ключевого слова implements мы перенимаем методы интерфейса Figure для реализации.
Важно: в классе должны быть все методы интерфейса, даже если некоторые еще не реализованы, в противном случае компилятор будет выдавать ошибку и просить подключить все методы. Тело методов можно изменить только в интерфейсе, здесь только реализация.
Override – аннотация которая говорит, что метод переопределен.
И соответственно у нас есть 3 класса самих фигур, которые наследуются от класса Figure. Класс Figure является родительским классом или классом-родителем, а классы Circle, Rectungle и Triangle – являются дочерними.
public class Triangle extends devcolibri.com.oop.inheritance.Figure – это значит, что класс Triangle наследует класс Figure.
super.setColor(colour); – super модификатор, позволяющий вызывать методы из класса родителя.
Теперь каждый класс перенял свойства класса Figure. Что собственно это нам дало?
Значительно уменьшило время разработки классов самих фигур, дало доступ к полям и методам родительского класса.
Чем же extends отличается от implements? Extends дает нам намного гибче подход. Мы используем только те методы, что нам нужны, в любой момент мы можем изменить каркас и тело метода, или добавить совсем новый метод, который возможно будет использовать информацию от класса родителя, а implements все лишь формирует тело класса.
В дочерних классах мы можем спокойно добавлять новые интересующие нас методы. Например, мы хотим добавить в класс Triangle 2–а новых метода: flimHorizontal () и flipVertical ():
Теперь эти 2-а метода принадлежат сугубо классу Triangle. Этот подход используется когда базовый класс не может решить всех проблем.
Или можно использовать другой подход, изменить или переписать методы в дочерним классе:
Довольно интересный факт: в java запрещено множественное наследование, но любой из классов по умолчанию наследуется то класса Object. То есть при наследовании любого класса у нас получается множественное наследование.
Заключение
От любой методики разработки программного обеспечения мы ждем, что она поможет нам в решении наших задач. Но одной из самых значительных проблем проектирования является сложность. Чем больше и сложнее программная система, тем важнее разбить ее на небольшие, четко очерченные части. Чтобы справиться со сложностью, необходимо абстрагироваться от деталей. В этом смысле классы представляют собой весьма удобный инструмент.
Классы позволяют проводить конструирование из полезных компонентов, обладающих простыми инструментами, что позволяет абстрагироваться от деталей реализации.
Данные и операции над ними образуют определенную сущность, и они не разносятся по всей программе, как нередко бывает в случае процедурного программирования, а описываются вместе. Локализация кода и данных улучшает наглядность и удобство сопровождения программного обеспечения.
Инкапсуляция позволяет привнести свойство модульности, что облегчает распараллеливание выполнения задачи между несколькими исполнителями и обновление версий отдельных компонентов.
ООП дает возможность создавать расширяемые системы. Это одно из основных достоинств ООП, и именно оно отличает данный подход от традиционных методов программирования. Расширяемость означает, что существующую систему можно заставить работать с новыми компонентами, причем без внесения в нее каких–либо изменений. Компоненты могут быть добавлены на этапе исполнения программы.
Полиморфизм оказывается полезным преимущественно в следующих ситуациях.
Обработка разнородных структур данных. Программы могут работать, не различая вида объектов, что существенно упрощает код. Новые виды могут быть добавлены в любой момент.
Изменение поведения во время исполнения. На этапе исполнения один объект может быть заменен другим, что позволяет легко, без изменения кода, адаптировать алгоритм в зависимости от того, какой используется объект.
Реализация работы с наследниками. Алгоритмы можно обобщить настолько, что они уже смогут работать более чем с одним видом объектов.
Создание «каркаса» (framework). Независимые от приложения части предметной области могут быть реализованы в виде набора универсальных классов, или каркаса (framework), и в дальнейшем расширены за счет добавления частей, специфичных для конкретного приложения.
Часто многоразового использования программного обеспечения не удается добиться из–за того, что существующие компоненты уже не отвечают новым требованиям. ООП помогает этого достичь без нарушения работы уже имеющихся компонентов, что позволяет извлечь максимум из многоразового использования компонентов.
Сокращается время на разработку, которое может быть отдано другим задачам.
Компоненты многоразового использования обычно содержат гораздо меньше ошибок, чем вновь разработанные, ведь они уже не раз подвергались проверке.
Когда некий компонент используется сразу несколькими клиентами, улучшения, вносимые в его код, одновременно оказывают положительное влияние и на множество работающих с ним программ.
Если программа опирается на стандартные компоненты, ее структура и пользовательский интерфейс становятся более унифицированными, что облегчает ее понимание и упрощает использование.
Недостатки ООП. Документирование классов – задача более трудная, чем это было в случае процедур и модулей. Поскольку любой метод может быть переопределен, в документации должно говориться не только о том, что делает данный метод, но и о том, в каком контексте он вызывается. Ведь переопределенные методы обычно вызываются не клиентом, а самим каркасом. Таким образом, программист должен знать, какие условия выполняются, когда вызывается данный метод. Для абстрактных методов, которые пусты, в документации должно говориться о том, для каких целей предполагается использовать переопределяемый метод.
В сложных иерархиях классов поля и методы обычно наследуются с разных уровней. И не всегда легко определить, какие поля и методы фактически относятся к данному классу. Для получения такой информации нужны специальные инструменты, вроде навигаторов классов. Если конкретный класс расширяется, то каждый метод обычно сокращают перед передачей сообщения базовому классу. Реализация операции, таким образом, рассредотачивается по нескольким классам, и чтобы понять, как она работает, нам приходится внимательно просматривать весь код.
Методы, как правило, короче процедур, поскольку они осуществляют только одну операцию над данными, зато их намного больше. В коротких методах легче разобраться, но они неудобны тем, что код для обработки сообщения иногда «размазан» по многим маленьким методам.
Инкапсуляцией данных не следует злоупотреблять. Чем больше логики и данных скрыто в недрах класса, тем сложнее его расширять. Отправной точкой здесь должно быть не то, что клиентам не разрешается знать о тех или иных данных, а то, что клиентам для работы с классом этих данных знать не требуется.
Многие считают, что ООП является неэффективным. Как же обстоит дело в действительности? Мы должны проводить четкую грань между неэффективностью на этапе выполнения, неэффективностью в смысле распределения памяти и неэффективностью, связанной с излишней универсализацией.
Неэффективность на этапе выполнения. В языках типа Smalltalk сообщения интерпретируются во время выполнения программы путем осуществления их поиска в одной или нескольких таблицах и за счет выбора подходящего метода. Конечно, это медленный процесс. И даже при использовании наилучших методов оптимизации Smalltalk–программы в десять раз медленнее оптимизированных C–программ.
В гибридных языках типа Oberon–2, Object Pascal и C++ отправка сообщения приводит лишь к вызову через указатель процедурной переменной. На некоторых машинах сообщения выполняются лишь на 10% медленнее, чем обычные процедурные вызовы. И поскольку сообщения встречаются в программе гораздо реже других операций, их воздействие на время выполнения влияния практически не оказывает.
Однако существует другой фактор, который влияет на время выполнения: это инкапсуляция данных. Рекомендуется не предоставлять прямой доступ к полям класса, а выполнять каждую операцию над данными через методы. Такая схема приводит к необходимости выполнения процедурного вызова каждый раз при доступе к данным. Однако если инкапсуляция используется только там, где она необходима (т.е. в тех случаях, когда это становится преимуществом), то замедление вполне приемлемое.
Неэффективность в смысле распределения памяти. Динамическое связывание и проверка типа на этапе выполнения требуют по ходу работы информацию о типе объекта. Такая информация хранится в дескрипторе типа и он выделяется один на класс. Каждый объект имеет невидимый указатель на дескриптор типа для своего класса. Таким образом, в объектно–ориентированных программах необходимая дополнительная память выражается в одном указателе для объекта и в одном дескрипторе типа для класса.
Излишняя универсальность. Неэффективность также может означать, что в программе реализованы избыточные возможности. В библиотечном классе часто содержится больше методов, чем это реально необходимо. А поскольку лишние методы не могут быть удалены, они становятся мертвым грузом. Это не влияет на время выполнения, но сказывается на размере кода.
Одно из возможных решений – строить базовый класс с минимальным числом методов, а затем уже реализовывать различные расширения этого класса, которые позволят нарастить функциональность. Другой подход – дать компоновщику возможность удалять лишние методы. Такие интеллектуальные компоновщики уже существуют для различных языков и операционных систем.
Но нельзя утверждать, что ООП неэффективно. Если классы используются лишь там, где это действительно необходимо, то потеря эффективности из–за повышенного расхода памяти и меньшей производительности незначительна. Кроме того, надежность программного обеспечения и быстрота его написания часто бывает важнее, чем производительность.
Список использованной литературы
Асхабов, Х. И. Методические основы использования информационных технологий в диагностической деятельности педагога : монография / Х. И. Асхабов, Б. С. Садулаева, Р. С. Хатаева. — Грозный : ЧГПУ, 2019. — 132 с. — ISBN 978-5-00128-397-3. — Текст : электронный // Лань : электронно-библиотечная система. — URL: https://e.lanbook.com/book/139413 (дата обращения: 06.12.2020). — Режим доступа: для авториз. пользователей.
Бордовский, Г. А. Технологии подготовки специалистов для инновационной деятельности в сфере образования. Методические рекомендации : методические рекомендации / Г. А. Бордовский, Н. Ф. Родионова, Е. В. Пискунова. — Санкт-Петербург : РГПУ им. А. И. Герцена, 2011. — 193 с. — ISBN 978-5-8064-1657-6. — Текст : электронный // Лань : электронно-библиотечная система. — URL: https://e.lanbook.com/book/5608 (дата обращения: 06.12.2020). — Режим доступа: для авториз. пользователей.
Калитвин, А. С. Численные методы. Использование C++ : учебное пособие / А. С. Калитвин. — Липецк : Липецкий ГПУ, 2019. — 143 с. — ISBN 978-5-907168-67-1. — Текст : электронный // Лань : электронно-библиотечная система. — URL: https://e.lanbook.com/book/156074 (дата обращения: 06.12.2020). — Режим доступа: для авториз. пользователей.
Миниярова, Л. В. Программирование в среде Visual Basic. Net : учебное пособие / Л. В. Миниярова, М. Р. Богданов. — Уфа : БГПУ имени М. Акмуллы, 2007. — 252 с. — ISBN 5-87978-246-8 . — Текст : электронный // Лань : электронно-библиотечная система. — URL: https://e.lanbook.com/book/43224 (дата обращения: 06.12.2020). — Режим доступа: для авториз. пользователей.
Технологии подготовки специалистов для инновационной деятельности в сфере образования : учебно-методическое пособие / под редакцией Г. А. Бордовского [и др.]. — Санкт-Петербург : РГПУ им. А. И. Герцена, 2011. — 194 с. — ISBN 978-5-8064-1657-6. — Текст : электронный // Лань : электронно-библиотечная система. — URL: https://e.lanbook.com/book/49983 (дата обращения: 06.12.2020). — Режим доступа: для авториз. пользователей.
