Qual é a definição de "interface" na programação orientada a objetos

Ok, um amigo meu vai e volta sobre o que "interface" significa em programação.

Qual é a melhor descrição de uma "interface".

Para mim, uma interface é um projeto de classe, esta é a melhor definição?

Uma interface é um dos termos mais sobrecarregados e confusos em desenvolvimento.

Na verdade, é um conceito de abstração e encapsulamento. Para uma determinada "caixa", declara as "entradas" e "saídas" dessa caixa. No mundo do software, isso geralmente significa as operações que podem ser invocadas na caixa (junto com os argumentos) e, em alguns casos, os tipos de retorno dessas operações.

O que ele não faz é definir qual é a semântica dessas operações, embora seja comum (e uma prática muito boa) documentá-las próximo à declaração (por exemplo, por meio de comentários) ou escolher boas convenções de nomenclatura. No entanto, não há garantias de que essas intenções seriam seguidas.

Aqui está uma analogia: Dê uma olhada em sua televisão quando estiver desligada. Sua interface são os botões que possui, os vários plugues e a tela. Sua semântica e comportamento são que ele recebe entradas (por exemplo, programação a cabo) e tem saídas (exibição na tela, som, etc.). No entanto, quando você olha para uma TV que não está conectada, você está projetando sua semântica esperada em uma interface. Pelo que você sabe, a TV pode explodir quando você a conecta. No entanto, com base em sua "interface", você pode presumir que ela não fará café, pois não tem entrada de água.

Na programação orientada a objetos, uma interface geralmente define o conjunto de métodos (ou mensagens) aos quais uma instância de uma classe que possui essa interface pode responder.

O que aumenta a confusão é que em algumas linguagens, como Java, há uma interface real com sua semântica específica da linguagem. Em Java, por exemplo, é um conjunto de declarações de métodos, sem implementação, mas uma interface também corresponde a um tipo e obedece a várias regras de digitação.

Em outras linguagens, como C ++, você não tem interfaces. A própria classe define métodos, mas você pode pensar na interface da classe como as declarações dos métodos não privados. Devido à forma como o C ++ é compilado, você obtém arquivos de cabeçalho onde poderia ter a "interface" da classe sem implementação real. Você também pode imitar as interfaces Java com classes abstratas com funções virtuais puras, etc.

Uma interface certamente não é um projeto para uma classe. Um projeto, por definição, é um "plano de ação detalhado". Uma interface não promete nada sobre uma ação! A fonte da confusão é que na maioria das linguagens, se você tem um tipo de interface que define um conjunto de métodos, a classe que o implementa "repete" os mesmos métodos (mas fornece definição), de modo que a interface parece um esqueleto ou um esboço da aula.

Considere a seguinte situação:

Você está no meio de uma grande sala vazia quando um zumbi o ataca de repente.

Você não tem arma.

Felizmente, um outro ser humano vivo está parado na porta da sala.

"Rápido!" você grita com ele. "Jogue-me algo com que eu possa acertar o zumbi!"

Agora, considere:
você não especificou (nem se importa) exatamente o que seu amigo escolherá jogar;
... Mas não importa, desde que:

• É algo que pode ser jogado (ele não pode jogar o sofá para você)

• É algo que você pode agarrar (espero que ele não tenha jogado uma shuriken)

• É algo que você pode usar para quebrar os miolos do zumbi (isso exclui travesseiros e tal)

Não importa se você ganha um taco de beisebol ou um martelo -
contanto que ele implemente suas três condições, você está bem.

Resumindo:

Quando você escreve uma interface, basicamente está dizendo: "Preciso de algo que ..."

Interface é um contrato que você deve cumprir ou cumprir, dependendo se você é um implementador ou um usuário.

Não acho que "planta" seja uma boa palavra para se usar. Um projeto informa como construir algo. Uma interface especificamente evita dizer a você como construir algo.

Uma interface define como você pode interagir com uma classe, ou seja, quais métodos ela suporta.

Para mim, uma interface é um projeto de classe, esta é a melhor definição?

Não. Um projeto geralmente inclui os internos. Mas uma interface é puramente sobre o que é visível do lado de fora de uma classe ... ou mais precisamente, uma família de classes que implementam a interface.

A interface consiste em assinaturas de métodos e valores de constantes e também em um "contrato comportamental" (tipicamente informal) entre as classes que implementam a interface e outras que a utilizam.

Na programação, uma interface define qual o comportamento de um objeto, mas não especifica o comportamento. É um contrato que vai garantir que uma determinada classe possa fazer alguma coisa.

Considere esta parte do código C # aqui:

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());

A classe Game requer um número secreto. Para fins de teste, você gostaria de injetar o que será usado como um número secreto (este princípio é chamado de Inversão de Controle).

A classe do jogo quer ter a "mente aberta" sobre o que realmente criará o número aleatório, portanto, ela pedirá em seu construtor "qualquer coisa que tenha um método Gerar".

Primeiro, a interface especifica quais operações um objeto fornecerá. Ele apenas contém a aparência, mas nenhuma implementação real é fornecida. Esta é apenas a assinatura do método. Convencionalmente, em C # as interfaces são prefixadas com um I. As classes agora implementam a interface IGenerate. Isso significa que o compilador se certificará de que ambos têm um método que retorna um int e é chamado Generate. O jogo agora está sendo chamado de dois objetos diferentes, cada um implementando a interface correta. Outras classes produziriam um erro ao construir o código.

Aqui eu notei a analogia do projeto que você usou:

Uma classe é comumente vista como um projeto para um objeto. Uma Interface especifica algo que uma classe precisará fazer, portanto, pode-se argumentar que é apenas um projeto para uma classe, mas como uma classe não precisa necessariamente de uma interface, eu diria que essa metáfora está quebrando. Pense em uma interface como um contrato. A classe que o "assina" será legalmente exigida (imposta pela polícia compiladora), para cumprir os termos e condições do contrato. Isso significa que terá que fazer o que está especificado na interface.

Isso tudo se deve à natureza estaticamente tipada de algumas linguagens OO, como é o caso com Java ou C #. Por outro lado, em Python, outro mecanismo é usado:

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

Aqui, nenhuma das classes implementa uma interface. Python não se preocupa com isso, porque a SecretGameclasse apenas tentará chamar qualquer objeto que for passado. Se o objeto TEM um método generate (), está tudo bem. Se isso não acontecer: KAPUTT! Este erro não será visto em tempo de compilação, mas em tempo de execução, possivelmente quando seu programa já estiver implantado e rodando. C # iria notificá-lo muito antes de você chegar perto disso.

A razão pela qual esse mecanismo é usado, afirmado ingenuamente, porque em linguagens OO naturalmente as funções não são cidadãos de primeira classe. Como você pode ver, KnownNumbere SecretNumbercontém APENAS as funções para gerar um número. Na verdade, não é preciso ter aulas. Em Python, portanto, pode-se simplesmente descartá-los e escolher as funções por conta própria:

# 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)

Um lambda é apenas uma função, que foi declarada "na linha, conforme você avança". Um delegado é o mesmo em C #:

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

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

Nota lateral: Os últimos exemplos não eram possíveis assim até o Java 7. Lá, as interfaces eram a sua única maneira de especificar este comportamento. No entanto, Java 8 introduziu expressões lambda para que o exemplo C # possa ser convertido para Java muito facilmente ( Func<int>torna java.util.function.IntSupplier- =>se e torna - se ->).

Tecnicamente, eu descreveria uma interface como um conjunto de maneiras (métodos, propriedades, acessores ... o vocabulário depende da linguagem que você está usando) para interagir com um objeto. Se um objeto suporta / implementa uma interface, então você pode usar todas as formas especificadas na interface para interagir com este objeto.

Semanticamente, uma interface também pode conter convenções sobre o que você pode ou não fazer (por exemplo, a ordem em que você pode chamar os métodos) e sobre o que, em troca, você pode assumir sobre o estado do objeto dado como você interagiu assim longe.

Pessoalmente, vejo uma interface como um modelo. Se uma interface contém a definição para os métodos foo () e bar (), então você sabe que cada classe que usa essa interface possui os métodos foo () e bar ().

Vamos considerar que um homem (usuário ou objeto) deseja que algum trabalho seja feito. Ele entrará em contato com um intermediário (Interface) que fará um contrato com as empresas (objetos do mundo real criados a partir de classes implementadas). Poucos tipos de obras serão por ele definidos quais empresas vão implementar e dar resultados. Cada empresa implementará o trabalho à sua maneira, mas o resultado será o mesmo. Assim, o usuário realizará seu trabalho usando uma única interface. Acho que a Interface atuará como parte visível dos sistemas com poucos comandos que serão definidos internamente pelos subsistemas internos de implementação.

Uma interface separa as operações em uma classe da implementação interna. Assim, algumas implementações podem fornecer muitas interfaces.

As pessoas geralmente o descreveriam como um "contrato" para o que deve estar disponível nos métodos da classe.

Não é absolutamente um projeto, já que isso também determinaria a implementação. Uma definição de classe completa pode ser considerada um projeto.

Uma interface define o que uma classe que herda dela deve implementar. Desta forma, várias classes podem herdar de uma interface e, por causa dessa herança, você pode

• certifique-se de que todos os membros da interface são implementados na classe derivada (mesmo que seja apenas para lançar uma exceção)
• Abstraia a própria classe do chamador (lance uma instância de uma classe para a interface e interaja com ela sem precisar saber qual é a classe derivada real)

para obter mais informações, consulte http://msdn.microsoft.com/en-us/library/ms173156.aspx

Em minha opinião, interface tem um significado mais amplo do que aquele comumente associado a ela em Java. Eu definiria "interface" como um conjunto de operações disponíveis com alguma funcionalidade comum, que permite controlar / monitorar um módulo.

Nesta definição, tento cobrir tanto as interfaces programáticas, onde o cliente é algum módulo, quanto as interfaces humanas (GUI por exemplo).

Como outros já disseram, uma interface sempre tem algum contrato por trás dela, em termos de entradas e saídas. A interface não promete nada sobre o "como" das operações; garante apenas algumas propriedades do resultado, dado o estado atual, a operação selecionada e seus parâmetros.

Como acima, sinônimos de "contrato" e "protocolo" são apropriados.

A interface compreende os métodos e propriedades que você pode esperar que sejam expostos por uma classe.

Portanto, se uma classe Cheetos Bagimplementa a Chip Baginterface, você deve esperar que Cheetos Baga se comporte exatamente como qualquer outra Chip Bag. (Ou seja, exponha o .attemptToOpenWithoutSpillingEverywhere()método, etc.)

Definição Convencional - Uma interface é um contrato que especifica os métodos que precisam ser implementados pela classe que a implementa.

A definição de interface mudou com o tempo. Você acha que a Interface tem apenas declarações de método? E as variáveis ​​finais estáticas e as definições padrão após o Java 5.

As interfaces foram introduzidas no Java por causa do problema do Diamond com herança múltipla e é isso que eles realmente pretendem fazer.

As interfaces são as construções que foram criadas para resolver o problema de herança múltipla e podem ter métodos abstratos, definições padrão e variáveis ​​finais estáticas.

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

Um limite através do qual dois sistemas se comunicam.

As interfaces são como algumas linguagens OO alcançam polimorfismo ad hoc . O polimorfismo ad hoc consiste simplesmente em funções com os mesmos nomes operando em tipos diferentes.

Resumindo, o problema básico que uma interface está tentando resolver é separar como usamos algo de como ele é implementado. Mas você deve considerar que a interface não é um contrato . Leia mais aqui .