Общая информация

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

Основные принципы ООП

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

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

Полиморфизм

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

Языки ООП

Принципы ООП используются в таких наиболее популярных языках программирования, как C++ и Java, на которых разработана значительная часть программ и приложений. Есть и менее используемые языки ООП - это Delphi, Object Pascal, Ruby и многие другие.

Критика ООП

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

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

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

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

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

Идея классов является основной объектно-ориентированного программирования (ООП). Основные принципы ООП были разработаны еще в языках Simula-67 иSmallTalk, но в то время не получили широкого распространения из-за трудностей освоения и низкой эффективности реализации.

Конкретные величины типа данных «класс» называют экземплярами класса илиобъектами (objects ) .

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

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

ООП - это метод программирования, развивающий принципы структурного программирования и основанный на следующих абстракциях данных:

I. Инкапсуляция : объединение данных с процедурами и функциями в единый блок программного кода (данные и методы работы с ними рассматриваются как поля объекта).

II. Наследование – передача методов и свойств от предка к потомку, без необходимости написания дополнительного программного кода (наличие экземпляров класса; потомки, прародители, иерархия).

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

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

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

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

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

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

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

Класс, который определяется через наследование от другого класса, называется производным классом (derived class ) , илиподклассом (subclass ) . Класс, от которого производится новый класс, называетсяродительским классом (parent class ) , илисуперклассом (superclass ) .

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

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

В дополнение к наследуемым сущностям производный класс может добавлять новые сущности и модифицировать методы. Модифицированный метод имеет то же самое имя и часто тот же самый протокол, что и метод, модификацией которого он является. Говорят, что новый метод замещает (override) наследуемую версию метода, который поэтому называется замещаемым (overriden) методом. Наиболее общее предназначение замещающего метода - выполнение операции, специфической для объектов производного класса и не свойственной для объектов родительского класса.

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

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

Полиморфизм

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

Вычисления в объектно-ориентированных языках

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

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

Библиотека визуальных компонентов (Visual Component Library, VCL)

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

Все классы VCL расположены на определенном уровне иерархии и образуют дерево (иерархию) классов .

Знание происхождения объекта оказывает значительную помощь при его изучении, так как потомок наследует все элементы объекта-родителя. Так, если свойство Caption принадлежит классу TControl, то это свойство будет и у его потомков, например, у классов TButton и TCheckBox и у компонентов - кнопки Button и независимого переключателя CheckBox соответственно. Фрагмент иерархии классов с важнейшими классами показан на рис.

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

Из своего опыта могу сказать, что всегда считал что понимал ООП, что же тут такого то - полиморфизм, инкапсуляция и наследование, но вот когда дошло до дела, то туговато пришлось. Хочу разложить всё по полочкам чтобы никто не наступил на мои грабли в будущем:)

Шаг 1.

Немного теории:

Объектно-ориентированное программирование (в дальнейшем ООП) - парадигма программирования, в которой основными концепциями являются понятия объектов и классов.

В центре ООП находится понятие объекта.

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

Наличие инкапсуляции достаточно для объектности языка программирования, но ещё не означает его объектной ориентированности - для этого требуется наличие наследования.

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

Хочу выделить что очень часто натыкаюсь на мнение, что в ООП стоит выделять еще одну немаловажную характеристику - абстракцию. Официально её не вносили в обязательные черты ООП, но списывать ее со счетов не стоит.

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

Инкапсуляция - это свойство системы, позволяющее объединить данные и методы, работающие с ними в классе, и скрыть детали реализации от пользователя.

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

Полиморфизм - это свойство системы использовать объекты с одинаковым интерфейсом без информации о типе и внутренней структуре объекта.

Шаг 2.

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

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

Зачем же это нужно?

Думаю, вам бы не хотелось, чтобы кто-то, что-то изменял в написанной вами библиотеки.

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

Цель инкапсуляции – уйти от зависимости внешнего интерфейса класса (то, что могут использовать другие классы) от реализации. Чтобы малейшее изменение в классе не влекло за собой изменение внешнего поведения класса. Давайте рассмотрим, как ею пользоваться.

Существует 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 вида.

Шаг 3.

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

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

Наследование является важным, поскольку оно позволяет поддерживать концепцию иерархии классов (hierarchical classification). Применение иерархии классов делает управляемыми большие потоки информации.

Разберем этот механизм на классическом примере: Геометрические фигуры.

У нас есть интерфейс Figure:

Public interface Figure { public void draw (); public void erase (); public void move (); public String getColor (); public boolean setColor (); }

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

Public class Figure implements сайт.oop.inheritance.interfaces.Figure{ @Override public void draw() { //need to implement } @Override public void erase() { //need to implement } @Override public void move(int pixel) { //need to implement } @Override public String getColor() { return null; } @Override public boolean setColor(String colour) { return false; } }

В этом классе мы реализуем все методы интерфейса Figure .

public class Figure implements сайт.oop.inheritance.interfaces.Figure - с помощью ключевого слова implements мы перенимаем методы интерфейса Figure для реализации.

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

И соответственно у нас есть 3 класса самих фигур, которые наследуются от класса Figure. Класс Figure является родительским классом или классом-родителем, а классы Circle, Rectungle и Triangle - являются дочерними.

Public class Circle extends Figure { @Override public void draw() { super.draw(); } @Override public void erase() { super.erase(); } @Override public void move(int pixel) { super.move(pixel); } @Override public String getColor() { return super.getColor(); } @Override public boolean setColor(String colour) { return super..oop.inheritance.Figure{ @Override public void draw() { super.draw(); } @Override public void erase() { super.erase(); } @Override public void move(int pixel) { super.move(pixel); } @Override public String getColor() { return super.getColor(); } @Override public boolean setColor(String colour) { return super..oop.inheritance.Figure{ @Override public void draw() { super.draw(); } @Override public void erase() { super.erase(); } @Override public void move(int pixel) { super.move(pixel); } @Override public String getColor() { return super.getColor(); } @Override public boolean setColor(String colour) { return super.setColor(colour); } }

public class Triangle extends сайт.oop.inheritance.Figure - это значит, что класс Triangle наследует класс Figure .

super.setColor(colour); - super модификатор, позволяющий вызывать методы из класса родителя.

Теперь каждый класс перенял свойства класса Figure. Что собственно это нам дало?

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

Наверное возник вопрос: чем же extends отличается от implements ?

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

В дочерних классах мы можем спокойно добавлять новые интересующие нас методы. Например, мы хотим добавить в класс Triangle 2-а новых метода: flimHorizontal () и flipVertical ():

/** * New Method */ public void flipVertical () { }; /** * New Method */ public void flipHorizontal () { };

Теперь эти 2-а метода принадлежат сугубо классу Triangle . Этот подход используется когда базовый класс не может решить всех проблем.

Или можно использовать другой подход, изменить или переписать методы в дочерним классе:

Довольно интересный факт: в java запрещено множественное наследование, но любой из классов по умолчанию наследуется то класса Object . То есть при наследовании любого класса у нас получается множественное наследование)

Но не стоит забивать этим голову!

Шаг 4.

Полиморфизм.

В более общем смысле, концепцией полиморфизма является идея “один интерфейс, множество методов “.

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

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

Public class Parent { int a = 2; } public class Child extends Parent { int a = 3; }

Прежде всего, нужно сказать, что такое объявление корректно.

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

Компилятор может опираться только на тип ссылки, с помощью которой происходит обращение к полю:

Child c = new Child(); System.out.println(c.a); // результатом будет 3 Parent p = c; System.out.println(p.a); //результатом будет 2

Данное объявление так и называется – «скрывающим ». Родительское поле продолжает существовать.

К нему можно обратиться явно:

Class Child extends Parent { int a = 3; //скрывающее объявление int b = ((Parent)this).a; //громоздкое обращение к родительскому полю int c = super.a; //простое обращение к родительскому полю }

Переменные b и c получат значения, родительского поля a . Хотя выражение с super более простое, оно не позволит обратиться на два уровня вверх по дереву наследования.

А ведь вполне возможно, что в родительском классе это поле также было скрывающим и в родителе родителя храниться ещё одно значение.

К нему можно обратиться явным приведением, как это делается для b .

Class Parent { int x = 0; public void printX() { System.out.println(x); } } class Child extends Parent { int x = -1; }

Каков будет результат для new Child.printX() ; ?

Метод вызывается с помощью ссылки типа Child , но метод определен в классеParent и компилятор расценивает обращение к полю x в этом методе именно как к полю класса Parent . Результатом будет 0 .

Рассмотрим случай переопределения методов:

Class Parent { public int getValue() { return 0; } } class Child extends Parent { public int getValue() { return 1; } } Child c = new Child(); System.out.println(c.getValue()); // результатом будет 1 Parent p = c; System.out.println(p.getValue()); // результатом будет 1

Родительский метод полностью перекрыт.

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

Хотя старый метод снаружи недоступен, внутри класса-наследника к нему можно обратиться с помощью super .

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

Шаг 5.

Абстракция:

Как говорилось в начале статьи, нельзя игнорировать абстракцию, а значит и абстрактные классы и методы.

В контексте ООП абстракция - это обобщение данных и поведения для типа, находящегося выше текущего класса по иерархии.

Перемещая переменные или методы из подкласса в супер класс, вы обобщаете их. Это общие понятия, и они применимы в языке Java. Но язык добавляет также понятия абстрактных классов и абстрактных методов .

Абстрактный класс является классом, для которого нельзя создать экземпляр.

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

Издаваемый звук зависит от вида животного.

Как это смоделировать?

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

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

Использование абстракции:

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

Public abstract class Person { abstract void move(); abstract void talk(); } public class Adult extends Person { public Adult() { } public void move() { System.out.println("Walked."); } public void talk() { System.out.println("Spoke."); } } public class Baby extends Person { public Baby() { } public void move() { System.out.println("Crawled."); } public void talk() { System.out.println("Gurgled."); } }

Что мы сделали в приведенном выше коде?

Мы изменили Person и указали методы как abstract , заставив подклассы реализовывать их.
Мы сделали Adult подклассом Person и реализовали эти методы.
Мы сделали Baby подклассом Person и реализовали эти методы.

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

Теперь, поскольку Adult и Baby являются подклассами Person , мы можем обратиться к экземпляру каждого класса как к типу Person.

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

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

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

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

Основные концепции ООП

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

Центральный элемент ООП - абстракция . Данные с помощью абстракции преобразуются в объекты, а последовательность обработки этих данных превращается в набор сообщений, передаваемых между этими объектами. Каждый из объектов имеет свое собственное уникальное поведение. С объектами можно обращаться как с конкретными сущностями, которые реагируют на сообщения, приказывающие им выполнить какие-то действия.

ООП характеризуется следующими принципами ( по Алану Кею):

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

Определение 10.1 . Абстрагирование (abstraction) - метод решения задачи, при котором объекты разного рода объединяются общим понятием (концепцией), а затем сгруппированные сущности рассматриваются как элементы единой категории.

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

Определение 10.2 . Инкапсуляция (encapsulation) - техника, при которой несущественная с точки зрения интерфейса объекта информация прячется внутри него.

Определение 10.3 . Наследование (inheritance) - свойство объектов, посредством которого экземпляры класса получают доступ к данным и методам классов-предков без их повторного определения.

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

Определение 10.4 .

Объектно-ориентированное программирование (ООП) является в настоящее время наиболее популярной технологией про­граммирования. Объектно-ориентированное программирова­ние является развитием технологии структурного програм­мирования, однако имеет свои характерные черты.

Наиболее распространенными системами объектно-ориен­тированного визуального программирования являются Mic­rosoft Visual Basic и Borland Delphi.

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

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

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

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

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

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

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

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

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

Еще один принцип ООП – принцип полиморфизма.

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

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

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

При этом подходе доступ к из­менению свойств объекта возмо­жен только через принадлежа­щие этому объекту методы. Методы «окружают» свойства объекта; говорят, что свойства «инкапсулированы» в объект.

Таким образом, в объект­но-ориентированном программи­ровании центральное место занимают объекты, которые объ­единяют в одно целое (инкапсулируют) свойства объекта и возможные над ним операции (методы).

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

Например, файловая система компьютера может содер­жать сотни и тысячи файлов. Все файлы обладают одним я тем же набором свойств (имя, положение в файловой системе и др.) и операций (переименование, перемещение или ко­пирование и др.) и образуют класс объектов Файлы.

Каждый отдельный файл является экземпляром этого класса и имеет конкретные значения свойств (имя, местопо­ложение и др.).

Часто встречается ситуация, когда над объектами различных классов можно совершать одинако­вые операции. Для большинства классов объектов в среде Windows (папки, документы, символы и др.) также характерен набор одних и тех же операций (переименование, перемещение, копирование, удаление и т.д.). Такое единообразие очень удобно для пользователя.

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

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

Объекты, обладающие одинаковыми наборами свойств и методов, образуют класс объектов. Так, в приложении Word существует класс объектов документ (Documents), который обладает такими свойствами как имя (Name), местоположе­ ние (FileNaine) и др. Объекты этого класса обладают также определенным набором методов, например: открытие доку­ мента (Open), печать документа (Printout), сохранение документа (Save) и т.д.

Объекты в приложениях образуют некоторую иерархию. На вершине иерархии объектов находится приложение (Ap­plication). Так, иерархия объектов приложения Word включает в себя следующие объекты: приложение (Applica­tion), документ (Documents), фрагмент документа (Se­lection), символ (Character) и др.

Иерархия объектов приложения Excel включает в себя следующие объекты: приложение (Application), книга (Workbook), лист (Worksheet), диапазон ячеек (Range), ячей­ ка (Cell) и др.

Полная ссылка на объект состоит из ряда имен вложен­ных последовательно друг в друга объектов. Разделителями имен объектов в этом ряду являются точки, ряд начинается с объекта наиболее высокого уровня Application и заканчи­вается именем интересующего нас объекта. Например, ссыл­ка на документ Пpo6a.doc в приложении Word будет выгля­деть следующим образом:

Application . Documents ("Пpo6a.doc")

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

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

Для каждого события можно запрограммировать отклик, то есть реакцию объекта на произошедшее событие. Такая программа называется событийной процедурой . Имя событийной процедуры принято составлять из имени объекта и имени события. Например, для объекта «кнопка» с именем Command 1 и события Click («нажатие», которое наступает, когда мы наводим с помощью мыши стрелку курсора на изображение кнопки и нажимаем левую кнопку мыши) событийная процедура получит имяCommand 1_ Click .

В событийной процедуре может участвовать несколько объектов. Например, в упомянутой выше процедуре Command 1_ Click может присутствовать команда

Text 1. Text = “Привет!”,

в результате выполнения которой в объекте «текстовое поле» с именем Text 1 появится строка со словом «Привет!».

Визуальное программирование, методы которого используются средой разработки Visual Basic позволяет создавать графический интерфейс разрабатываемых приложений на основе использования управляющих элементов, к котором относятся кнопки (CommandButton), флажки (CheckBox) , текстовые поля (TextBox), поля со списком (ListBox) и другие. Эти объекты, их свойства и методы будут рассмотрены в следующем разделе. Пока лишь отметим, что управляющие элементы чаще всего используются для получения от пользователя данных и вывода результатов работы приложения. Таким образом, управляющие элементы являются основой для построения пользовательского интерфейса приложения.

Основными объектами, используемыми при визуальном программировании, являются формы (Form). Форма представляет собой окно, на котором размещаются управляющие элементы. Форма также представляет собой объект, характеризуемый набором свойств и методов. Как и для любого другого объекта для формы можно написать событийную процедуру, например Form _ Load , которая запускается при наступлении события Load («загрузка») и в результате работы которой будут выполнены инструкции, необходимые для работы запускаемого приложения.