Откуда взялась концепция интерфейсов?

Может быть, Java?

http://java.sun.com/docs/books/tutorial/java/concepts/interface.html

Они пришли из java и были введены потому, что java (и C#) не допускают множественного наследования.

Обновлено: Я получаю несколько даунмодов, потому что люди, использующие COM-интерфейсы в C++, не согласны с приведенным выше утверждением. Несмотря на это, концепция интерфейса пришла из java, интерфейсы C++ COM были виртуальными классами, java был первым языком, который сделал его функцией языка.

КОНЕЦ РЕДАКТИРОВАНИЯ

Например, в C++ у вас может быть класс с именем Dog, унаследованный от Animal и Mammal.

В C# у вас будет базовый класс с именем Animal и будет использоваться интерфейс (IMammal). Обозначение именования I является историческим из C++ (оно использовалось для обозначения абстрактного виртуального класса) и было перенесено в java, но более важно в C#, поскольку нет простого способа определить, что является базовым классом, а что - интерфейс из объявления класса C#:

public class Dog : Animal, IMammal

в то время как в Java это было более очевидно:

public class Dog extends Animal implements IMammal

Множественное наследование очень сложно, поэтому интерфейсы были созданы для его упрощения. Класс C# может наследовать только от одного базового класса, но может реализовывать N интерфейсов.

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

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

C++ допускает множественное наследование. Когда была разработана Java, было принято решение о единственном наследовании, однако классам было разрешено реализовывать несколько интерфейсов. C# развил эту концепцию.

Думаю, основная идея - «множественное наследование». Идея пришла из C++.

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

class IFoo
{
public:
  void Bar() =0;
  void Bar2() =0;
};

class Concrete : public IFoo
{
public:
  void Bar() { ... }
  void Bar2() { ... }
}

Они существовали в C++, но были известны как виртуальные базовые классы, которые состояли только из чистых виртуальных функций. Вот откуда появился префикс «I-» для интерфейсов - чтобы отличать виртуальные базовые классы от абстрактных базовых классов.

Я сначала видел интерфейс ключевых слов в java, но они намного старше этого.

та же концепция существует в C++, но это не совсем то же самое. Их называют «чистыми виртуальными классами».

http://en.wikipedia.org/wiki/Virtual_function

Они существуют с другим синтаксисом, но позволяют полиморфизм в ООП.

В C++ у вас может быть абстрактный класс без реализации, и вы можете наследовать несколько классов. Java и C# избавились от множественного наследования, поэтому, чтобы иметь возможность наследовать множественные контракты (не поведения), они создали интерфейсы. Вы можете наследовать только один класс в C#, но вы можете наследовать столько интерфейсов, сколько захотите.

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

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

Интерфейсы существовали в C++, если вы занимались программированием на COM, откуда и берет свое начало соглашение IPrefix.

Хотя сам C++ изначально не поддерживал интерфейсы, COM / C++ использовал библиотеки типов, сгенерированные из языка определения интерфейсов, который имеет единственную цель определения интерфейсов, и использовал ключевое слово интерфейс задолго до того, как это сделали Java или C#.

Помимо разрешения формы множественного наследования, мотивация .NET для интерфейсов связана с его компонентно-ориентированным происхождением, и его основная цель - определить контракты между компонентами, которые могут взаимодействовать без какого-либо знания реализаций друг друга. Некоторое взаимодействие COM также выполняется с интерфейсами .NET.

Самая ранняя реализация интерфейсов, о которой я знаю в вычислительной технике, пришла от CORBA.

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

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

У меня создалось впечатление, что первая концепция интерфейсов формализованный пришла из Objective-C (так называемых «протоколов»). Я могу сказать вам наверняка, что Java, по крайней мере, получила идею от Objective-C, так что не у Java были интерфейсы первой.

Электронное письмо от Патрика Нотона

Интерфейсы довольно старые и существуют довольно давно.

Ранние (с середины до конца 1970-х) не объектно-ориентированные языки, такие как Modula и Euclid, использовали конструкции, называемые «модулями», для определения интерфейсов между компонентами. Затем компоненты будут взаимодействовать друг с другом через явные модули импорта и экспорта. Интерфейсы в C# - это объектно-ориентированное развитие той же концепции.

Интерфейсы в C# напрямую происходят от концепции интерфейсов в C++ (и Java), где они использовались как часть COM для описания интерфейсов объектно-ориентированных компонентов.

Обновлено: В ходе небольшого исследования первым языком, который я смог найти с явным ключевым словом «интерфейс», был Modula-3, производный от Modula, созданный примерно в 1986 году.

Интерфейсы пришли из информатики. Или, скажем, из здравого смысла в программировании. Интерфейс - это логическая группа методов класса. C++ не нуждался в отдельная языковая концепция «interface», потому что любой класс мог бы использоваться в качестве интерфейса - просто определите в нем набор методов, не делайте реализации, вызовите его как IExecutable и используйте:

class IExecutable
{
public:
    virtual void Execute() = 0;
};

class MyClass : public IExecutable
{
public:
    void Execute() { return; };
};

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

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

public interface IPurring
{
    void Purr();
}

public class Cat : Animal, IPurring
{
    public Cat(bool _isAlive)
    {
        isAlive = _isAlive;
    }

    #region IPurring Members

    public void Purr()
    {
        //implement purring
    }

    #endregion
}

Хотя они и не называются «интерфейсами», указатели структур данных C с указателями функций в качестве элементов структуры реализовали концепцию интерфейсов задолго до того, как С ++ сделал это с виртуальными базовыми классами IMO.

Я считаю, что интерфейсы возникли из-за того, что некоторые программисты устали писать реализацию метода снова и снова. Сколько раз вы можете написать:

static string Method(int i)

не задумываясь, должен быть способ попроще?

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