Я нашел эту цитату в "Радость в Clojure" на стр. 32, но кто-то сказал мне то же самое за ужином на прошлой неделе, и я'вэ слышал это в другом месте, а также:
[а] недостатком объектно-ориентированного программирования является жесткой связь между функцией и данными.
Я понимаю, почему ненужную связь плохая в приложении. Также Я'м комфортно говорят, что состоянии изменчивости и наследования следует избегать, даже в объектно-ориентированном программировании. Но я не понимаю, зачем вставлять функции на классы-Это изначально плохо.
Я имею в виду, добавив функцию в класс, кажется, как пометки почте в Gmail, или вставлять файл в папку. Это'с организационной техникой, которая поможет вам найти его снова. Вы выбираете какие-то критерии, а затем положить вместе, как вещи. Перед ООП, наши программы были довольно большими мешками методов в файлах. Я имею в виду, вы должны поставить где-нибудь функций. Почему бы не организовать их?
Если это завуалированная атака на видах, почему Дон't они просто говорят, что ограничение типа входные и выходные функции неправильно? Я'м не уверен, смог ли я с этим согласен, но, по крайней мере, я'м знакомы с аргументами за и против тип безопасности. Для меня это звучит как в основном отдельный концерн.
Конечно, иногда люди ошибаются и ставят функциональность на неправильный класс. Но по сравнению с другими ошибками, мне кажется, это очень мелкое неудобство.
Итак, какие пространства имен. Сколько торчит функция класса в ООП отличается от наклеивания функция в пространстве имен в Clojure и почему это так плохо? Помните, функций в классе Дон'т должен работать только на членов этого класса. Посмотрите на Java.яз.То StringBuilder - это работает с любым ссылочным типом, или через авто-бокс на любой тип.
P. S. Эта цитата ссылается на книгу, которую я еще не читал: мультипарадигмальное программирования в Leda: Тимоти Бадд, 1995.
В теории, свободные функции-данные муфты делает его легче, чтобы добавить больше функций, чтобы работать на тех же данных. С другой стороны это делает его более трудным, чтобы изменить структуру данных, чего на практике, хорошо продуманные функциональные код и продуманный код ООП имеют очень похожие уровни сцепления.
Принять ориентированный ациклический граф (Даг) в качестве примера структуры данных. В функциональном программировании, вам нужны еще какие-то абстракции, чтобы избежать повторения себя, так что вы'ре собирается сделать модуль с функциями добавления и удаления вершин и ребер, найти узлы достижимы из данного узла, создать топологическую сортировку и т. д. Эти функции эффективно тесно связан с данными, даже если компилятор не'т реализовать это. Вы можете добавить узел трудный путь, но зачем вы хотите? Сколоченность в одном модуле предотвращает плотное соединение всей системы.
Наоборот на ООП стороны, какие-либо другие функции, кроме основных операций Дага-это будет сделано в отдельной "На посмотреть" и классов, с Даг объект, переданный в качестве параметра. Это's просто, как легко добавить столько видом, сколько вы хотите, которые работают на Даг данных, создавая тот же уровень функции данные развязки как в функциональной программе. Компилятор выиграл'т держать вас от зубрежки все в один класс, но и ваши коллеги.
Изменение парадигм программирования не't изменить лучшие практики абстракции, единства и связи, он просто меняет какие практики компилятор помогает внедрить. В функциональном программировании, когда вы хотите, чтобы функция-данные соединения это'ы обеспечивается господа'соглашения, а не компилятор. В ООП, модель-вид разделения обеспечивается господа'соглашения, а не компилятор.
В случае, если вы не'т знаю, что это уже принять это понимание: концепции объектно-ориентированного и закрытие две стороны одной медали. Что сказал, что это закрытие? Он принимает переменную(ые) или сведения из окружающей сферы и связывается с ней внутри функции, или ОО-точки зрения вы эффективно делать то же самое, когда вы, например, что-то передавать в конструктор, так что в дальнейшем вы можете использовать этот кусок данных в функцию-член этого экземпляра. Но, принимая вещи из окружающей области видимости, это не хорошая вещь, чтобы сделать - чем больше окружающая область, тем больше зла он должен сделать это (хоть и прагматично, какой-то злой часто необходимо для работы). Использование глобальных переменных доводя до крайности, где функции в программе используются переменные в области видимости программы - действительно зло. Есть подробное описание в другом месте о том, почему глобальные переменные-это зло.
Если вы будете следовать ОО методов, которые вы в основном уже признать, что каждый модуль в программе, будут иметь определенный минимальный уровень зла. Если вы получите функциональный подход к программированию, вы стремитесь к идеальным, где нет модуля в вашей программе будет содержать закрытие зла, хотя вы можете все еще есть некоторые, но это будет намного меньше, чем ОО.
Что'ы вниз ОО - она поощряет такого рода зло, соединения в функции данных путем закрытия стандартных (своего рода теория разбитых окон Программирование).
Единственная положительная сторона заключается в том, что, если вы знали, что вы собираетесь использовать много закрытий, чтобы начать с, ОО, по крайней мере, предоставляет вам механизм идеологической, чтобы помочь организовать такой подход тем, что средний программист может понять. В частности, переменные закрываются более четко в конструкторе, а не просто принимать неявно в закрытии функции. Функциональные программы, которые используют много закрытий часто более загадочно, чем эквивалентные программы ОО, хотя и не обязательно менее элегантно :)
Это's О типа соединение:
Функция встроена в объект для работы на этом объекте может'т быть использованы на другие типы объектов.
В Haskell можно писать функции для работы с типом - классы - таким образом, есть много различных типов объектов функция может работать как против, так долго, как это'ы типа данных класс эта функция работает на.
Свободностоящая функции позволяют такие развязки, которые вы не'т вам, когда вы сосредоточиться на написании функций для работы внутри типа a, потому что тогда вы можете'т использовать их, если вы Don'т иметь тип экземпляра, хотя функция в противном случае могут быть достаточно общей, чтобы быть использовано на тип B или тип C экземпляр экземпляр.
В Java и подобные воплощения ООП, методов экземпляра (в отличие от свободной функции или методы расширения) может'т быть добавлены из других модулей.
Это становится более ограничения если учесть интерфейсов, которые могут быть реализованы только методы экземпляра. Вы можете'т определить интерфейс и класса в разных модулях, а затем использовать код из третьего модуля, чтобы связать их вместе. Более гибкий подход, как Хаскелл's классов типа должны быть в состоянии сделать это.
Объектная ориентация-это принципиально абстракции о процедурной абстракции данных (или функциональные данные если убрать побочные эффекты, которые являются другой вопрос). В некотором смысле, лямбда-исчисление является самым старым и самым чистым объектно-ориентированным языком, поскольку он только обеспечивает функциональную абстракцию данных (потому что это не'Т есть какие-либо создает, помимо функций).
Только на работу один объект может проверить, что объект'представление данных. Даже не другие объекты однотипные можете сделать это. (В этом заключается основное различие между объектно-ориентированной абстракции данных и абстрактные типы данных: с помощью абстрактных типов данных, объекты одного типа могут проверять друг друга'с данным представлением, только представление объектов другие типы скрыта).
Это означает, что несколько объектов одного типа могут иметь разные представления данных. Даже тот же объект может иметь разные представления данных в разное время. (Например, в Scala, карты и установите переключатель между массив и хэш-дерева в зависимости от количества элементов, поскольку для очень малых чисел линейный поиск в массиве быстрее, чем логарифмический поиск в дереве поиска из-за очень малых постоянных факторов.)
От внешнего объекта, вы должны'т вы можете'т - знать свои данные представительства. Что'ы напротив тугое сцепление.
Тесная взаимосвязь между данными и функциями-это плохо, потому что вы хотите быть в состоянии изменить каждый независимо друг от друга и тесная взаимосвязь делает это трудно, потому что вы можете't изменить одну без знания и, возможно, изменения, другой.
Вы хотите, чтобы разные данные, представленные функции не требует никаких изменений в функции а так же вы хотите, чтобы иметь возможность вносить изменения в функции без каких-либо изменений в данных, которые он работает на, чтобы поддержать эти изменения функции.