Каково определение "интерфейса" в объектно-ориентированном программировании

рассмотрим следующую ситуацию:

вы находитесь в центре большой пустой комнаты, когда зомби внезапно нападает на вас.

у вас нет оружия.

к счастью, в дверях комнаты стоит еще один живой человек.

"быстро!- ты кричишь на него. - Брось мне что-нибудь, чем я могу ударить зомби!"

теперь рассмотрим:
Вы не указали (и вам все равно) точно что ваш друг решит бросить;
...Но это не имеет значения, пока:

• Это можете быть брошенным (он не может бросить вам диван)

• Это то, что вы можете схватить (будем надеяться, что он не кидал сюрикен)

• Это то, что вы можете использовать, чтобы вышибить мозги зомби (это исключает подушки и прочее)

Это не имеет значения, получаете ли вы бейсбольную биту или молоток -
пока он реализует ваши три условия, Вы хороши.

в итоге:

когда вы пишете интерфейс, вы в основном говорите: "мне нужно что-то это..."

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

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

интерфейс определяет, как вы можете взаимодействовать с классом, т. е. какие методы он поддерживает.

для меня интерфейс-это чертеж класса, это лучшее определение?

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

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

технически, я бы описал интерфейс как набор способов (методы, свойства, методы доступа... словарь зависит от языка, который вы используете) для взаимодействия с объектом. Если объект поддерживает / реализует интерфейс, то для взаимодействия с этим объектом можно использовать все способы, указанные в интерфейсе.

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

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

рассмотрим этот фрагмент кода C# здесь:

using System;

public interface IGenerate
{
    int Generate();
}

// Dependencies
public class KnownNumber : IGenerate
{
    public int Generate() 
    {
        return 5;
    }   
}

public class SecretNumber : IGenerate
{
    public int Generate()
    {
        return new Random().Next(0, 10);
    }
}

// What you care about
class Game
{
    public Game(IGenerate generator) 
    {
        Console.WriteLine(generator.Generate())
    }
}

new Game(new SecretNumber());
new Game(new KnownNumber());

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

в игровой класс хочет быть "открытым" о том, что на самом деле создаст случайное число, поэтому он попросит в своем конструкторе "что-нибудь, что имеет метод генерации".

во-первых, интерфейс определяет, какие операции объект будет обеспечивать. Он просто содержит то, что он выглядит, но никакой фактической реализации не дается. Это всего лишь сигнатура метода. Условно, в интерфейсах C# с префиксом I. Классы теперь реализуют интерфейс IGenerate. Этот означает, что компилятор будет убедиться, что у них обоих есть метод, который возвращает int и называется Generate. Игра теперь называется два разных объекта, каждый из которых реализует правильный интерфейс. Другие классы будут производить ошибку при построении кода.

здесь я заметил аналогию с чертежом, которую вы использовали:

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

это все из-за статически типизированной природы некоторых языков OO, как это случай с Java или C#. С другой стороны, в Python используется другой механизм:

import random

# Dependencies
class KnownNumber(object):
    def generate(self):
        return 5

class SecretNumber(object):
    def generate(self):
        return random.randint(0,10)

# What you care about
class SecretGame(object):
    def __init__(self, number_generator):
        number = number_generator.generate()
        print number

здесь ни один из классов не реализует интерфейс. Python не заботится об этом, потому что SecretGame класс будет просто пытаться вызвать любой объект передается. Если объект имеет метод generate (), все в порядке. Если это не так: KAPUTT! Эта ошибка будет замечена не во время компиляции, а во время выполнения, поэтому, возможно, когда ваша программа уже развернута и запущена. C# будут уведомлять вы задолго до того, как приблизились к этому.

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

# OO Approach
SecretGame(SecretNumber())
SecretGame(KnownNumber())

# Functional Approach

# Dependencies
class SecretGame(object):
    def __init__(self, generate):
        number =  generate()
        print number

SecretGame(lambda: random.randint(0,10))
SecretGame(lambda: 5)

лямбда-это просто функция, которая была объявлена "в строке, как вы идти." Делегат точно такой же в C#:

class Game
{
    public Game(Func<int> generate) 
    {
        Console.WriteLine(generate())
    }
}    

new Game(() => 5);
new Game(() => new Random().Next(0, 10));

последние примеры не возможны, как это в Java, так как Java не может качаться с функциями, как другие два (Python и C#) может. Там, интерфейсы - ваш единственный способ speficiying поведения таким образом в av.

лично я вижу интерфейс, как шаблон. Если интерфейс содержит определение для методов foo () и bar (), то вы знаете, что каждый класс, который использует этот интерфейс, имеет методы foo () и bar ().

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

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

обывателя, например.: Подумайте о наличии универсального пульта дистанционного управления, который может управлять любым телевизором, то ли это старая трубка модель или тот, который использует ЖК-или плазменный экран. Вы нажимаете 2, затем 5, затем ввод, и на любом из экранов отобразится канал 25, хотя механизм, чтобы это произошло, сильно отличается в зависимости по базовой технологии.

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

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

Это абсолютно не план, так как это также определило бы реализацию. Полное определение класса можно было бы назвать чертежом.

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

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

для получения дополнительной информации см. Это http://msdn.microsoft.com/en-us/library/ms173156.aspx

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

в этом определении я пытаюсь охватить как программные интерфейсы, где клиент-это какой-то модуль, так и человеческие интерфейсы (например, GUI).

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

как и выше, синонимы "договор" и "протокол" соответствующие.

интерфейс содержит методы и свойства, которые вы можете ожидать от класса.

так что если класс Cheetos Bag осуществляет Chip Bag интерфейс, вы должны ожидать Cheetos Bag вести себя точно так же, как любой другой Chip Bag. (То есть разоблачить .attemptToOpenWithoutSpillingEverywhere() метод, etc.)

граница, через которую взаимодействуют две системы.

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

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

определение интерфейса изменилось с течением времени. Как вы думаете, интерфейс имеет только объявления методов ? Как насчет статических конечных переменных и определений по умолчанию после Java 5.

интерфейсы были введены в Java из-за проблемы алмаза с множественным наследованием, и это то, что они на самом деле намерены это сделать.

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

http://www.quora.com/Why-does-Java-allow-static-final-variables-in-interfaces-when-they-are-only-intended-to-be-contracts