Подтвердить что ты не робот

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

В С# у нас есть интерфейсы. Откуда они взялись? Они не существовали в С++.

4b9b3361

ОТВЕТЫ

Ответ 1

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

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

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

РЕДАКТИРОВАТЬ:. При проведении небольшого объема исследований самым ранним языком, который я смог найти с явным ключевым словом "interface", был Modula-3, производный от Modula, созданный примерно в 1986 году.

Ответ 2

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

Ответ 3

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

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

END EDIT

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

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

public class Dog : Animal, IMammal

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

public class Dog extends Animal implements IMammal

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

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

Ответ 4

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

Электронная почта от Патрика Нотона

Ответ 5

Интерфейсы существовали на С++, если вы выполняли программирование на COM, где и начинается соглашение IPrefix.

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

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

Ответ 6

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

Ответ 7

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

Ответ 8

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

та же концепция существует в С++, но она не совсем то же самое. Они называются "чистыми виртуальными классами"

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

Они существуют с различным синтаксисом, но существуют, чтобы разрешить полиморфизм в ООП.

Ответ 9

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

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

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

Ответ 10

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

static string Method(int i)

не думая, что должен быть более простой способ?

Ответ 11

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

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

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

Ответ 12

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

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

Ответ 13

Интерфейсы взяты из компьютерных наук. Или, скажем, из здравого смысла в программировании. Интерфейс является логической группой методов класса. Для С++ не нужна отдельная языковая концепция "интерфейса", потому что любой класс может использоваться как интерфейс - просто определите в нем набор методов, не выполняйте реализацию, назовите его как IExecutable и используйте:

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

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

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

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

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
}

Ответ 14

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

Ответ 15

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

Ответ 17

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

Ответ 18

Я думаю, что основная идея - "множественное наследование". Итак, идея исходила из С++.