В чем суть интерфейсов в программировании? Общее понятие интерфейса и сравнение с абстрактным классом. Интерфейс и абстрактный класс

Для начала нужно сразу понять, что интерфейс это частный случай класса. Но в Java оно имеет отдельное ключевое слово, а в C++ это просто класс без реализации. Поэтому интерфейс просто задает некий стандарт для работы с кучей разнообразных реализаций.

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

А если вы делаете игру, то можете создать интерфейс Unit, тем самым задав классам определенное поведение. Например, unit должен обязательно иметь метод atack(), isDead() и т.д.

Ну и конечно Unit может быть и просто классом или абстрактным классом, в котором реализованы atack и isDead, а может быть только isDead, потому что attack у каждого типа юнита индивидуально и требует собственной реализации. Т.е. приходим к тому, что интерфейс это также частный случай абстрактного класса.

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

И соответсвенно если Unit у вас будет классом или абстрактным классом, то унаследовав Unit в Java, вы просто не сможете дать наследнику еще и Iterable поведение, если Iterable будет тоже классом.

OrcWarrior implements Unit, Iterable - так можно

OrcWarrior extends Unit, Iterable - так в Java нельзя, но можно в С++, а Unit и Iterable тогда всегда будут объявляться как class...

Из-за этого, в Java приветствуется не наследование, а композиция. Т.е. нафига каждый раз реализовывать Unit.isDead, если он стандартный? Поэтому, создается скажем класс UnitAI и делается следующее:

Class OrcWarrior implements Unit, Iterable {
UnitAI ai;

UnitAI getAI(){
return ai;
}
}

Boolean isDead() {
....
}
}

Interface Unit {
void attack();
UnitAI getAI();
}

Вот это называется композиция, т.е. в OrcWarrior, HumanWarrior вы подмешиваете UnitAI, в котором уже реализовано isDead, и тем самым не нужно каждый раз его реализовывать одним и тем же кодом. В С++ такого можно не делать, там есть поддержка множественного наследование, но оно имеет свои минусы. Впрочем, как и композиция имеет плюсы/минусы.

В PHP ООП интерфейс — это класс, в котором все методы являются абстрактными и открытыми.

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

Интерфейс PHP представляет собой инструмент для создания надежного кода, определяющего методы, которые должны быть реализованы с помощью класса без определения обработки этих методов. Это мощная и простая концепция, используемая в объектно-ориентированном PHP . Для его создания используется ключевое слово interface , он определяется так же, как класс PHP . Методы, содержащиеся в нем, не имеют никакого функционала, но интерфейс задает, какие методы необходимы для других классов. Любой класс, наследующийся от интерфейса, должен содержать те же методы, которые содержатся в интерфейсе, иначе выдается ошибка.

В интерфейсе ООП PHP мы задаем только имена методов и их параметры, а реализованы они могут быть позже. Принято объявлять все методы интерфейса как public . Для реализации интерфейса используется ключевое слово implements . При необходимости класс может реализовать более одного интерфейса, между собой они разделяются запятой. Как и класс, интерфейс может содержать константы. Единственное отличие заключается в том, что они не могут быть переопределены в производном классе.

Определение и использование интерфейсов

Интерфейс определяется с помощью ключевого слова interface . Все методы в нем должны быть открытыми и абстрактными:

interface animal { }

Это пустой интерфейс. Мы добавим в него абстрактный метод motion . Таким образом, мы создадим простой PHP 5 ООП интерфейс, который может быть реализован позже:

interface animal { public function motion(){} }

Этот интерфейс может быть реализован любым классом animal , все классы animal будут содержать метод motion . Давайте рассмотрим пример. Для реализации интерфейса мы используем ключевое слово implements :

PHP-интерфейс и абстрактные классы

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

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

Для чего используются интерфейсы PHP

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

Корректировка кода в будущем

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

Лучшая структура программы

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

Добавление всех важных функций

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

Еще один в ООП PHP пример реализации интерфейса

class Cake implements Recipe { public function methodology() { } }

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

Перевод статьи «PHP interface » был подготовлен дружной командой проекта .

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

Описание и использование интерфейсов

Описание ООП-интерфейса, если отвлечься от деталей синтаксиса конкретных языков, состоит из двух частей:

Имя интерфейса, которое строится по тем же правилам, что и другие идентификаторы используемого языка программирования. Разные языки и среды разработки имеют различные соглашения по оформлению кода, в соответствии с которыми имена интерфейсов могут формироваться по некоторым правилам, облегчающим отличение имени интерфейса от имён других элементов программы. Например, в технологии COM и всех поддерживающих её языках действует соглашение, согласно которому имя интерфейса строится по шаблону «I<Имя>», то есть состоит из написанного с заглавной буквы осмысленного имени, которому предшествует прописная латинская буква I (IUnknown, IDispatch, IStringList и так далее).
Методы интерфейса. В описании интерфейса определяются имена и сигнатуры входящих в него методов, то есть процедур или функций класса.

Использование интерфейсов возможно двумя способами:

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

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

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

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

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

Интерфейсы и абстрактные классы

Можно заметить, что интерфейс, с точки зрения реализации - это просто чистый абстрактный класс , то есть класс, в котором не определено ничего, кроме абстрактных методов . Если язык программирования поддерживает множественное наследование и абстрактные методы (как, например, C++), то необходимости во введении в синтаксис языка, отдельного понятия «интерфейс» не возникает. Данные сущности описываются с помощью абстрактных классов и наследуются классами для реализации абстрактных методов.

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

Множественное наследование и реализация интерфейсов

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

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

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

Интерфейсы в конкретных языках и системах

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

В объектной подсистеме языка Object Pascal никаких интерфейсов не было, их поддержка была введена в Delphi 2 для обеспечения написания и использования COM-компонентов. Соответственно, механизм интерфейсов Delphi ориентирован, в первую очередь, на использование технологии COM.
В Java интерфейсы изначально входят в язык, являясь неотъемлемой его частью.
В C++ интерфейсов, строго говоря, нет вообще. Механизм, аналогичный интерфейсам (и, исторически предшествующий им) реализуется другими средствами чрезвычайно мощной объектной подсистемы этого языка.

Delphi

Объявление интерфейсов

Объявление интерфейсов очень похоже на упрощенное объявление классов.

Оно начинается с заголовка. Сначала указываются модификаторы. Интерфейс может быть объявлен как public и тогда он будет доступен для общего использования, либо модификатор доступа может не указываться, в этом случае интерфейс доступен только для типов своего пакета . Модификатор abstract для интерфейса не требуется, поскольку все интерфейсы являются абстрактными . Его можно указать, но делать этого не рекомендуется, чтобы не загромождать код .

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

Наследование интерфейсов действительно очень гибкое. Так, если есть два интерфейса, A и B , причем B наследуется от A , то новый интерфейс C может наследоваться от них обоих. Впрочем, понятно, что указание наследования от A является избыточным, все элементы этого интерфейса и так будут получены по наследству через интерфейс B.

public interface Directions {

Int RIGHT=1; int LEFT=2; int UP=3; int DOWN=4;

Все методы интерфейса являются public abstract и эти модификаторы также необязательны.

Описание ООП-интерфейса, если отвлечься от деталей синтаксиса конкретных языков, состоит из двух частей:

Имя интерфейса, которое строится по тем же правилам, что и другие идентификаторы используемого языка программирования. Разные языки и среды разработки имеют различные соглашения по оформлению кода, в соответствии с которыми имена интерфейсов могут формироваться по некоторым правилам, облегчающим отличение имени интерфейса от имён других элементов программы. Например, в технологии COM и всех поддерживающих её языках действует соглашение, согласно которому имя интерфейса строится по шаблону «I<Имя>», то есть состоит из написанного с заглавной буквы осмысленного имени, которому предшествует прописная латинская буква I (IUnknown, IDispatch, IStringList и так далее).
Методы интерфейса. В описании интерфейса определяются имена и сигнатуры входящих в него методов, то есть процедур или функций класса.

Использование интерфейсов возможно двумя способами:

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

Интерфейсы и абстрактные классы

Можно заметить, что интерфейс, фактически - это просто чистый абстрактный класс , то есть класс, в котором не определено ничего, кроме абстрактных методов . Если язык программирования поддерживает множественное наследование и абстрактные методы (как, например, C++), то необходимости во введении отдельного понятия «интерфейс» не возникает. Аналогичные сущности описываются в виде абстрактных классов и наследуются классами для реализации абстрактных методов.

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

Множественное наследование и реализация интерфейсов

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

Интерфейсы в конкретных языках и системах

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

В объектной подсистеме языка Object Pascal никаких интерфейсов не было, их поддержка была введена в Delphi 2 для обеспечения написания и использования COM-компонентов. Соответственно, механизм интерфейсов Delphi ориентирован, в первую очередь, на использование технологии COM.
В Java интерфейсы изначально входят в язык, являясь неотъемлемой его частью.
В C++ интерфейсов, строго говоря, нет вообще. Механизм, аналогичный интерфейсам (и, исторически предшествующий им) реализуется другими средствами чрезвычайно мощной объектной подсистемы этого языка.

Delphi

В COM технологии фирмы Delphi напоминают классы. Как все классы являются наследниками класса

Пример объявления интерфейса:

IMyInterface = interface procedure DoSomething; end ;

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

Вышеупомянутая ориентированность интерфейсов Delphi на технологию COM привела к некоторым неудобствам. Дело в том, что интерфейс IUnknown (от которого наследуются все остальные интерфейсы) уже содержит три метода: QueryInterface,_AddRef, _Release , следовательно, любой класс, реализующий любой интерфейс, обязан реализовать эти методы, даже если интерфейс и класс не имеют никакого отношения к COM.

Пример класса, реализующего интерфейс

TMyClass = class(TMyParentClass, IMyInterface) procedure DoSomething; function QueryInterface(const IID: TGUID; out Obj) : HResult; stdcall ; function _AddRef: Integer ; stdcall ; function _Release: Integer ; stdcall ; end ;

C++

Java

Объявление интерфейсов

Объявление интерфейсов очень похоже на упрощенное объявление классов.

Public interface Directions { int RIGHT=1; int LEFT=2; int UP=3; int DOWN=4; }

Все методы интерфейса являются public abstract и эти модификаторы также необязательны.

Public interface Moveable { void moveRight(); void moveLeft(); void moveUp(); void moveDown(); }

Как мы видим, описание интерфейса гораздо проще, чем объявление класса.

Реализация интерфейса

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

Interface I { void interfaceMethod() ; } public class ImplementingInterface implements I { void interfaceMethod() { System .out .println ("Этот метод реализован из интерфейса I" ) ; } public static void main(String args) { ImplementingInterface temp = new ImplementingInterface() ; temp.interfaceMethod () ; } }

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

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

Interface A { int getValue() ; } interface B { double getValue() ; } interface C { int getValue() ; } public class Correct implements A, C // класс правильно наследует методы с одинаковой сигнатурой { int getValue() { return 5 ; } } class Wrong implements A, B // класс вызывает ошибку при компиляции { int getValue() { return 5 ; } double getValue() { return 5.5 ; } }

В процессе поиска новой работы столкнулся с тем, что все работодатели хотят, чтобы было отличное знание ООП в ПХП. Чем я хуже других, подумал я, и решил перечитать главу про объектно-ориентированное программирование. И вот на очередном собеседовании мне задают вопрос — чем абстрактный класс отличается от интерфейса.
Единственное отличие, которое я знал было в том, что один класс может реализовать несколько различных интерфейсов. Но обо всем по порядку.

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

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

value = NULL; } } class Integer extends Number { private $value; public function value() { return (int)$this->value; } } $num = new Integer; /* Все в порядке */ $num2 = new Number; /* Возникнет ошибка */ ?>

abstract class Number {

private $value ;

abstract public function value () ;

public function reset () {

$this -> value = NULL ;

class Integer extends Number {

private $value ;

public function value () {

return (int ) $this -> value ;

$num = new Integer ; /* Все в порядке */

$num2 = new Number ; /* Возникнет ошибка */

Тут мы создали абстрактный класс Number, который является расширением класса Integer. Поскольку класс Number объявлен как abstract, на его основе нельзя создавать экземпляры. Если посмотреть на класс Number, то можно увидеть, что в нем определены две функции: value() и reset(). Абстрактный класс может не содержать код для методов, хотя при необходимости его можно добавить. Что же касается класса Number, то поскольку функция value() является специфической для конкретного типа числа, она реализуется в классе-наследнике. Чтобы разработчик мог реализовать такое поведение в своем коде, используется ключевое слово abstract, указывающее на то, что это просто заполнитель в классе Number. Однако это не относится к методу reset(), который остается неизменным для любого конкретного типа числа.

Интерфейсы
В отличие от абстрактных классов, посредством которых можно выражать абстрактные понятия в программах, интерфейсы предназначены для того, чтобы обеспечить определенную функциональность внутри класса. Если выражаться точнее, то интерфейс представляет собой средство для определения набора методов, которые должен иметь класс, реализующий данный интерфейс. Чтобы использовать интерфейс, его необходимо объявить с указанием ключевого слова interface:

interface printable {

public function printme () ;

Чтобы интерфейс приносил определенную пользу, он должен быть реализован с помощью одного или нескольких классов. Далее будет определен интерфейс printable, который заявляет, что любой класс, реализующий этот интерфейс, должен реализовать метод printme(). Чтобы создать класс, реализующий подобный интерфейс, в определении класса используется ключевое слово implements, за которым следует список реализованных интерфейсов:

value; } public function printme() { echo (int)$this->value; } } ?>

class Integer implements printable {

echo (int ) $this -> value ;

Здесь определен исходный класс Integer, чтобы реализовать интерфейс printable. Как класс, реализующий этот интерфейс, он гарантирует, что класс Integer предложит все методы, которые определены в интерфейсе.

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

P.S. — Большая часть статьи — не моя, а взята из книги, где, на мой взгляд, наиболее понятно описана разница между абстрактными классами и интерфейсами.
P.P.S. — Так же, не особо понятно зачем вообще нужно ООП в PHP, т.к. прям явных преимуществ я не вижу, а все это можно реализовать с помощью простых функций… Единственный раз, когда я за свою жизнь использовал ООП — это для реализации класса, работающего с базами данных.