Рабство программиста
Utkin
Оригинальный
текст - на сайте procoder.info
ООПрограммист - рядовой муравей, увеличивающий всемирную энтропию путем написания никому не нужного кода http://www.absurdopedia.wikia.com/wiki/ООП. Каждый из тех, кто знаком с принципами ООП, прекрасно знает о тех преимуществах, удобствах и больших плюсах, которые оно представляет программистам. Но так ли это на самом деле? Все познается в сравнении, преимущества по сравнению с чем?
Что такое ООП?
Да, что такое ООП? Несмотря на значительное время существования данной концепции точного определения ООП не существует и по сей день. Есть определения ООП в рамках конкретных языков программирования, но все они различны, имеют свою терминологию, механизмы использования, особенности реализации и т.д. Любой учебник по ООП даст Вам либо определение в привязке к языку программирования, либо весьма туманное объяснение или же вовсе, с места в карьер, речь пойдет о принципах, определениях класса и объекта и т.д. Не имея точного определения обучаемый, словно Алиса проваливается в кроличью нору нового для него мира. Особенно остро это ощущается, если уже имел навыки программирования. Но ощущения субъективны, рассмотрим основные концепции ООП под другим углом зрения.
Базовые понятия ООП
Их все знают, это:
•инкапсуляция
•наследование
•полиморфизм
Сейчас также добавляют еще понятие абстракции данных. Рассмотрим их всех по порядку...
Инкапсуляция – это принцип,
согласно которому любой класс должен рассматриваться как чёрный ящик —
пользователь класса должен видеть и использовать только интерфейсную часть
класса (т. е. список декларируемых свойств и методов класса) и не вникать в его
внутреннюю реализацию. Поэтому данные принято инкапсулировать в классе таким
образом, чтобы доступ к ним по чтению или записи осуществлялся не напрямую, а с
помощью методов. Принцип инкапсуляции (теоретически) позволяет минимизировать
число связей между классами и, соответственно, упростить независимую реализацию
и модификацию классов (определение взято из Википедии
http://ru.wikipedia.org/wiki/Объектно-ориентированное_программирование). Но, инкапсуляция не ноу-хау ООП, она
существовала и ранее – это обычное описание функций и процедур. Пример на
Паскале:
1.Function Sum (a, b:
Integer): Integer;
2.Begin
3.Result := a+b
4.End;
Чтобы использовать функцию мне не обязательно знать, как она устроена (и
в ряде случаев такое знание даже противопоказано), достаточно лишь описание
интерфейса Function Sum (a, b: Integer): Integer; Я должен знать, что имя
функции Sum, она принимает два параметра типа Integer (важен также порядок их
следования), возвращает также Integer, а вот каким образом проводится сложение
это уже совершенно безразлично. Еще пример:
1.Type
2.TMas = record
3.Data: Array of
Integer;
4.Count: Integer;
5.End;
6.Procedure Sort (var
Mas: TMas);
Теперь чтобы отсортировать такой вот массив, мне не нужно знать, как он устроен, сколько в нем элементов и т.д. Я просто передам его процедуре Sort. Так чем же примечательна инкапсуляция? Справедливости ради, надо отметить, что инкапсуляция как описание указанного выше явления получило признание только в ООП. Потому что такое определение там является одним из главных особенностей построения программ. Никаких преимуществ, в сравнении с теми же структурным или функциональным программированиями, инкапсуляция в ООП не несет.
Однако на этом инкапсуляция не заканчивается: cокрытие данных (взят из книги Тимоти Бадд «ООП в действии») - неотделимая часть ООП, управляющая областями видимости. Является логическим продолжением инкапсуляции. Целью сокрытия является невозможность для пользователя узнать или испортить внутреннее состояние объекта. Но это тоже существует в структурном программировании:
01.Function fact(x: integer): integer;
02.var
03.i, n: Integer;
04.begin
05.n:=1;
06.for i:=1 to x do
07.begin
08.n:=n*i;
09.end;
10.fact:=n;
11.end;
Разве я могу получить доступ к i и n не в рамках данной функции? Также
стоит еще раз внимательно почитать определение – невозможность для
пользователя. Если речь идет о программисте, то он испортить может все и вся и
никакое сокрытие данных Вам не поможет, по одной простой причине – раз имеются
данные, то также и имеются некоторые механизмы для их использования. Поэтому
область видимости не защищает данные от ошибок в методах данного класса. Пример на
Дельфи:
01.Type
02.MyClass = class
(TObject)
03.Protected
04.MyData: TStringList;
05.Private
06.Public
07.Constructor Create;
08.Destructor Destroy;
09.End;
10.Constructor
MyClass.Create;
11.Begin
12.Inherited Create
13.End;
14.Destructor
MyClass.Destroy;
15.Begin
16.Inherited Destroy
17.End;
Опытный программист уже догадался, о чем идет речь – любое обращение к MyData вызовет ошибку, поскольку перед использованием такие объекты нуждаются в инициализации (между прочим одна из распространенных ошибок начинающих программистов). Так что же дают игры с областями видимости? Если же говорить о методах других объектов, то доступа к MyData они не получат, но согласно принципам ООП они и не должны его получать. Иными словами MyData никогда не должен находиться в секции Public (кстати, Дельфи это позволяет). Доступ к полям класса всегда должен осуществляться через методы либо свойства. То есть здесь должна быть аналогия с функциями и процедурами структурного программирования – объявление структур данных должно осуществляться аналогично секции var. Это очень важный момент – сокрытие данных в рамках ООП предназначено для программирования программиста, а не реализации алгоритма. Я говорю о сокрытии данных, потому что я боюсь допустить ошибку, которая в рамках структурного программирования не может возникнуть в принципе. Компилятору безразлично, в какой секции находится поле, он выдаст код в любом случае (речь идет о Дельфи версии 7), все ограничения видимости введены для программиста. Если Вы думаете, что в С++ это невозможно, то сильно ошибаетесь и виной тому указатели (а в С++ указатели не менее важный механизм, нежели механизмы ООП). Имея указатель на класс, можно не только прочесть его приватные поля, но и модифицировать их.
01.Class Sneaky
02.{
03.private:
04.int safe;
05.public:
06.// инициализировать поле safe значением 10
07.Sneaky () { safe =
10; }
08.Int &sorry() {
return safe; }
09.}
10.И далее:
11.Sneaky x;
12.x.sorry () = 17;
Инкапсуляция тесно связана с таким понятием как абстрагирование. Это придание объекту характеристик, которые отличают его от всех других объектов, четко определяя его концептуальные границы. Основная идея состоит в том, чтобы отделить способ использования составных объектов данных от деталей их реализации в виде более простых объектов. И здесь снова модули и структуры решают эту задачу без участия ООП – интерфейсы функций, процедур и модулей могут полностью скрывать внутреннее представление по реализации тех или иных задач. Сомневаетесь? Вот пример взаимодействия модулей (Дельфи). Поместите на формуодну кнопку:
01.unit Unit1;
02.interface
03.uses
04.Windows, Messages,
SysUtils, Variants, Classes, Graphics, Controls, Forms,
05.Dialogs, Unit2,
StdCtrls;
06.type
07.TForm1 =
class(TForm)
08.Button1: TButton;
09.procedure
Button1Click(Sender: TObject);
10.procedure
FormCreate(Sender: TObject);
11.private
12.{ Private declarations
}
13.public
14.{ Public
declarations }
15.end;
16.var
17.Form1: TForm1;
18.implementation
19.{$R *.dfm}
20.procedure
TForm1.Button1Click(Sender: TObject);
21.begin
22.AddX();
23.Button1.Caption:=IntToStr(GetX());
24.end;
25.////////////////////////////////////////////////////////////////////////////////
26.procedure
TForm1.FormCreate(Sender: TObject);
27.begin
28.Init();
29.end;
30.////////////////////////////////////////////////////////////////////////////////
31.end.
И подключите второй модуль:
01.unit Unit2;
02.interface
03.procedure Init();
04.procedure AddX();
05.function GetX():
Integer;
06.implementation
07.var
08.x: Integer;
09.procedure Init();
10.begin
11.x:=0;
12.end;
13.////////////////////////////////////////////////////////////////////////////////
14.procedure AddX();
15.begin
16.x:=x+1;
17.end;
18.////////////////////////////////////////////////////////////////////////////////
19.function GetX():
Integer;
20.begin
21.result:=x;
22.end;
23.////////////////////////////////////////////////////////////////////////////////
24.end.
Выполните программу, понажимайте на кнопку. Теперь попробуйте получить доступ к Х без использования функций и процедур из Unit2. Модуль хранит в себе данные, скрывает их представление и ограничивает к ним доступ. При этом в Unit2 нет и намека на класс (и не думайте, что Вы сможете прочесть или изменить Х обычными процедурами и функциями Unit1 (не из формы)). Наследование один из четырёх важнейших механизмов объектно-ориентированного программирования, позволяющий описать новый класс на основе уже существующего (родительского), при этом свойства и функциональность родительского класса заимствуются новым классом. Не то чтобы я не согласен с таким определением, но давайте посмотрим очередной пример:
01.Type
02.TMas = record
03.Data: Array of
Integer;
04.Count: Integer;
05.End;
06.Type
07.TGroupMas = record
08.Data: Array of TMas;
09.Count: Integer;
10.End;
11.Procedure Sort (var
Mas: TMas);
Разве для построения TGroupMas я не опираюсь на TMas? Я ведь мог написать определение TGroupMas с нуля, но в моем случае каждый элемент массива Data структуры TGroupMas является ни кем иным как TMas. Более того, мне ничего не стоит написать процедуру сортировки указанного элемента TGroupMas. Все что требуется это лишь правильно передать параметры процедуре Sort. Таким образом, я описываю новую структуру TGroupMas данных на основании существующей TMas и я мог создать процедуру сортировки элемента массива на основании Sort:
1.Procedure SortItem
(var GropuMas: TGroupMas; Index: Integer);
2.Begin
3.Sort
(GroupMas.Data[Index]);
4.End;
При этом согласно определению наследования, я заимствую все свойства TMas и функциональность Sort; и все это в рамках структурного программирования, никакого ООП для этого не требуется. Вот пример, который часто любят давать в учебниках ООП (язык программирования Дельфи):
01.Type
02.TMaterial = record
03.Massa: Integer;
04.End;
05.Type
06.TAnimal = record
07.Material: TMaterial;
08.Sort: String;
09.End;
10.Type
11.TMamal = record
12.Animal: TAnimal;
13.Family: String;
14.End;
15.Type
16.THuman = record
17.Mamal: TMamal;
18.Race: String;
19.Floor: String;
20.Name: String;
21.Family: String;
22.End;
23.Type
24.TProgrammer = record
25.Human: THuman;
26.Sertificate: String;
27.End;
28.Type
29.TProgrammer_of_Pascal
= record
30.Programmer:
TProgrammer;
31.IDE: String;
32.End;
И пусть в меня «кинут камнем», если программист в данной иерархии не является млекопитающим и не обладает его свойствами (имеет массу, принадлежит к определенному виду).
TMaterial
|
TAnimal
|
TMamal
|
THuman
|
TProgrammer
|
TProgrammer_of_Pascal
Для использования механизма наследования не требуется использование объектно-ориентированного программирования. Достаточно, чтобы язык имел возможность организации структур данных определяемых программистом. Множественное наследование полностью аналогично – я могу определить новую структуру – цвет глаз и включить ее в TMamal и тогда программист обретет новые свойства. Кстати, множественное наследование одна из самых известных мозолей ООП, но именно поэтому о ней мы больше упоминать не будем. Цель данной статьи как раз показать те, моменты, о которых говорить не любят. Полиморфизм взаимозаменяемость объектов с одинаковым интерфейсом. Язык программирования поддерживает полиморфизм, если классы с одинаковой спецификацией могут иметь различную реализацию — например, реализация класса может быть изменена в процессе наследования. Кратко смысл полиморфизма можно выразить фразой: «Один интерфейс, множество реализаций». Можно сказать, что полиморфизм одна из самых загадочных концепций ООП. Итак, в некотором роде полиморфизм тесно связан с наследованием. Вы получаете некоторые методы от родительского класса и можете переопределить их функциональность. Адекватного механизма в структурном программировании не существует, но какие собственно выгоды дает полиморфизм? Итак, это выглядит следующим образом – некий класс (допустим программист) имеет в своем составе метод (допустим, пить чай). Программист на Яве переопределяет метод и пьет чай марки Ява под именем метода пить чай. То есть мы подразумеваем, что когда программист на Ява пьют чай, то он пьет чай марки Ява. Стандартно, формально, но теперь вопрос, какие в этом плюсы?
•уменьшение сложности программ;
•позволяет повторно использовать один и тот же код;
•позволяет использовать в потомках одинаковые имена методов для решения схожих задач.
Не густо, ну что, рассмотрим каждый пункт:
1.честно говоря, так и не увидел, в чем это выражается (хотя упоминается об этом практически везде), концепция структур и модулей достаточна для решения всех задач, которые могут быть решены полиморфизмом. С другой стороны, многочисленные одноименные методы усложняют программу. Результатом полиморфизма являются объекты, которые имеют и одноименные методы и могут работать с разными типами данных. Использование одноименных методов в таком случае не так тривиально, как хотелось бы. Пришлось срочно создавать новую концепцию (вернее сказать, воровать концепцию, поскольку ООП суть ряда заимствований от других парадигм) – RTTI. Проще всего ее можно представить как информацию о типе объекта во время выполнения программы. То есть перед запуском нужного метода используется явное определение того типа данных, с которым предстоит работать. Обычно такая ситуация возникает только в сложных программных объектах, но и полиморфизм в объектах с несложным поведением не имеет смысла и может быть заменен даже обычными операторами селекторами (например case в Дельфи) и введением дополнительных переменных. Более того, RTTI перечеркивает абстрагирование – для решения задачи динамически знать тип данных противопоказано, это увеличивает сцепляемость объектов – их сложней заменять, переносить, модернизировать. RTTI также уменьшает такую возможность полиморфизма, как использование обобщенных алгоритмов (о параметризации речь ниже).
2.об этом уже упоминалось:
01.Procedure SortItem
(var GropuMas: TGroupMas; Index: Integer);
02.
03.
04.
05.
06. Begin
07.
08.
09. Sort (GroupMas.Data[Index]);
10.
11.
12. End;
13.
Я же не пишу функцию сортировки снова, просто передаю ей нужные параметры. На лицо явное использование уже существующего ранее кода и совершенно без единого класса, поэтому никакого преимущества в сравнении скажем с функциональным программированием здесь нет. Если же речь идет о параметризации, то с каждым новым набором параметров генерируется новая версия этой же функции, поэтому код в таком случае используется не повторно, а каждый раз новый.
3.Я тоже могу написать кучу модулей для решения каждой задачи (все равно в классах каждое решение надо описывать явно) и вызывать их одноименные функции также через точечный синтаксис (в Дельфи), только в обратном порядке – имя_функции.имя_модуля. И я бы не сказал, что сильно путаюсь в программе, если однотипные действия названы по-разному (причем без разницы два у меня метода или десяток). Если имеется достаточно полное описание методов (те самые интерфейсы, которые ООП также считает своим достижением), и они имеют осмысленные имена, то никаких проблем между вызовом метода ProgrammTea и ProgrammJavaTea не возникает. ООП полностью игнорирует такие подходы как правильное оформление кода и правила именования объектов (хотя в нем же использование одноименных методов считается плюсом).
Организация тысячи то же что и организация одного. Это вопрос
организации (Конфуций).
Кроме того, я не считаю, что выбор нужного метода осуществляется компилятором – все действия жестко прописаны в каждом классе, а поскольку любой класс является еще и типом, то он ничего не выбирает, выбирает программист в каком классе, какой чай должен пить объект-программист на этапе переопределения родительского метода. Вот я бы задал список методов вообще без привязки к конкретному классу, просто как набор функций и процедур в отдельном модуле, а уж компилятор сам вызывал бы соответствующий метод, тогда я бы согласился с этим утверждением на все 100. Далее в современные библиотеки классов, обычно содержат более 100 классов, которые могут содержать десятки методов, и все их держать в голове никакой полиморфизм еще никогда не помогал… Без разницы сколько мне надо знать 1000 методов или 10 000, все равно их все помнить в любой момент времени нет необходимости. Что касается параметризации это действительно мощный механизм, но с теми же симптомами – это не универсальный рецепт, то есть имеет смысл его применять только в ряде случаев (часть из которых может быть решена комбинаторными алгоритмами) и преимущественно к простым типам. Вот пример алгоритма (С++):
1.// Описание шаблонной функции
2.template <typename T> T max(T x, T y)
3.{
4.if (x < y)
5.return y;
6.else
7.return x;
8.}
Не трудно догадаться, что она возвращает максимальный элемент из двух указанных, но только в том случае, если программист сможет описать строгое и однозначное сравнение объектов, то есть удобно для типов, которые по умолчанию поддерживаются транслятором. Для сложных типов, определяемых программистом параметризация не дает никаких преимуществ в сравнении с традиционными подходами. Весьма проблематична параметризация, когда в качестве типа выступают объекты классов, хотя, казалось бы, их строгая иерархия, наследование полей и полиморфизм должны как раз способствовать написанию обобщенных алгоритмов для работы с такими типами. Да это возможно, но требует тщательного продумывания иерархии и написание индивидуальных методов для каждого класса может оказаться предпочтительней.… Здесь решение аналогично RTTI, но проблема не в ООП, это попытка перешагнуть через строгое ограничение типов (наряду с типом Variant в Дельфи). Можно провести следующую аналогию – сначала перед бегуном понаставили барьеров и сказали, что теперь он будет учувствовать в беге с препятствиями, а потом пытаются научить его прыгать, выдают ему специальные кроссовки, рекомендуют методики тренировки…
Также не все гладко с перегрузкой операторов – трансляторы языков программирования часто не могут предоставить нужные средства идентификации перегруженных операторов (а те, что могут, сложны и не так эффективны, порождают большой и медлительный код), что вызывает двусмысленность в толковании всего выражения. Самый простой пример операция – (вычитание), дело в том, что она существует как минимум в двух видах это унарная операция и бинарная - -х и х-y (а в некоторых языках есть еще ее различные формы – инфиксная, постфиксная и т.д.). Далее, необходимо определить приоритет операции, скажем, для строк определение подобных операций может быть не так очевидно, как для чисел. Не думайте что сложение в этом случае лучше. Например, сложение строк x + y не эквивалентно y + x.
Также перегрузке свойственны общие беды полиморфизма – она не является обязательным элементом программирования (это значит, что нет алгоритмов, которые невозможно реализовать без использования перегрузки), и может привести к обратному результату – не упрощению, а усложнению программы. Подобно механизму RTTI перегрузка увеличивает связность кода – для понимания работы перегруженного оператора требуется знать тип объекта (или требуется его уточнение для понимания программистом) используемого в конкретной строке кода, отсюда всякие болячки – уменьшение переносимости, сложности при модификации отдельных объектов и т.д. Это еще один пример, когда не программист создает алгоритм, а язык программирует программиста – Вы должны следовать этому принципу, так как это приносит некоторые удобства, но при этом все умалчивают о том, что это не гарантия преодоления нарастающей сложности программ (и более того, такой механизм сам может являться источником усложнения программы). И еще один момент – полиморфизм не обязательная черта ООП. Это значит, что если Вы напишите программу, использующую классы и объекты, но не использующую полиморфизм, то это все равно будет ООП. Кроме того, если Вам не хочется отказываться от полиморфизма, его можно имитировать в рамках модулей (юнитов) программ.
Что еще, не так как надо
ООП «вещь в себе», и оно не вписывается в ряд задач – например механизм подключения DLL. Да, функция или процедура возвращает значение, но какого типа? Это отследить невозможно (и RTTI Вам не помощник). ООП очень плохо подходит для парсинга структурированных текстов (например, программ) в сравнении с функциональным программированием. ООП не дружит с рекурсией (не то чтобы она там не возможна, просто не эффективна в сравнении с тем же функциональным программированием), которая позволяет упростить представление многих задач. Также нужно учитывать, что программа, составленная без ООП, как правило, быстрей, чем с ним. ООП официально не поддерживает концепцию ленивых вычислений (вообще это черта языков функционального программирования) – потенциальное увеличение производительности, упрощение решения ряда задач.
Итоги
Данная статья вовсе не призывает отказываться от принципов ООП, задача дать более полное представление об некоторых аспектах ООП. Без понимания этих моментов программисты уверены, что ООП существенный шаг вперед (на самом деле существенный шаг вперед - обширные библиотеки, которые в свете новых веяний написаны в стиле ООП), хотя возможно, всего лишь шаг в сторону... Возьмите параметризацию – не стоит возлагать на нее большие надежды, она существует уже давно в том или ином виде в функциональном программировании (как и весь полиморфизм во всех его проявлениях) и пока не принесла кардинальных изменений в деле создания программ.
С.П.
Капица. Кому должна принадлежать
интеллектуальная собственность?
Программа - генератор
самоподобных случайных процессов