Куда понятие Интерфейсов прибывало из?

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

Я думаю, что основная идея является "множественным наследованием". Таким образом, идея прибыла из C++.

Java, возможно?

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

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

В то время как не названный 'интерфейсами', C указатели структуры данных с указателями функции, поскольку элементы структуры реализовали понятие интерфейсов задолго до того, как C++ сделал с виртуальными базовыми классами IMO.

Интерфейсы прибыли из информатики. Или, скажем, от здравого смысла в программировании. Интерфейс является логической группой методов класса. C++ не было нужно отдельное понятие языка "интерфейса", потому что любой класс мог бы использоваться в качестве интерфейса - просто определяют ряд методов в нем, не делают реализации, называют его как 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++ с чистыми виртуальными классами.

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

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

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

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

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

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

static string Method(int i)

не думая должен быть более легкий путь?

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

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

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

я видел, что ключевое слово взаимодействует через интерфейс сначала в Java, но они значительно старше, чем это.

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

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

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

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

Интерфейсы существовали в C++, если Вы сделали программирование COM, которое является, где конвенция IPrefix происходит.

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

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

У меня создалось впечатление, что первое формализованное понятие интерфейсов прибыло из Objective C (названный "протоколами"). Я могу сказать Вам наверняка, что Java, по крайней мере, получил идею от Objective C, таким образом, это не был Java, который имел интерфейсы сначала.

Электронная почта от Patrick Naughton

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

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

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

Например, в C++, у Вас мог быть класс под названием Собака, которая наследовалась Животному и Млекопитающему.

В C# Вы имели бы базовый класс под названием Животное и использовали бы интерфейс (IMammal). Я, называющий нотацию, является историческим от C++ (Это использовалось для указания на абстрактный виртуальный класс), и был перенесен на Java, но более значительный в C#, потому что нет никакого простого способа сказать то, что является базовым классом и что является интерфейсом из объявления класса C#:

public class Dog : Animal, IMammal

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

public class Dog extends Animal implements IMammal

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

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

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