Interface versus classe abstrata (OO geral)

Recentemente, tive duas entrevistas telefônicas nas quais me perguntaram sobre as diferenças entre uma classe Interface e uma classe Abstrata. Eu expliquei todos os aspectos deles em que pude pensar, mas parece que eles estão esperando que eu mencione algo específico, e eu não sei o que é.

Pela minha experiência, acho que o seguinte é verdade. Se estiver faltando um ponto importante, informe-me.

Interface:

Todo método declarado em uma interface terá que ser implementado na subclasse. Somente Eventos, Delegados, Propriedades (C #) e Métodos podem existir em uma Interface. Uma classe pode implementar várias interfaces.

Classe abstrata:

Somente métodos abstratos precisam ser implementados pela subclasse. Uma classe Abstract pode ter métodos normais com implementações. A classe abstrata também pode ter variáveis ​​de classe ao lado de Eventos, Delegados, Propriedades e Métodos. Uma classe pode implementar apenas uma classe abstrata apenas devido à inexistência de herança múltipla em C #.

1. Depois de tudo isso, o entrevistador surgiu com a pergunta "E se você tivesse uma aula abstrata com apenas métodos abstratos? Como isso seria diferente de uma interface?" Eu não sabia a resposta, mas acho que é a herança, como mencionado acima, certo?

2. Um outro entrevistador me perguntou e se você tivesse uma variável Public dentro da interface, como isso seria diferente do que na Abstract Class? Eu insisti que você não pode ter uma variável pública dentro de uma interface. Eu não sabia o que ele queria ouvir, mas ele também não estava satisfeito.

Veja também :

• Quando usar uma interface em vez de uma classe abstrata e vice-versa

• Interfaces vs. Classes Abstratas

• Como você decide entre usar uma classe abstrata e uma interface?

• Qual é a diferença entre uma interface e uma classe abstrata?

Embora sua pergunta indique que é para "OO geral", ela realmente parece estar se concentrando no uso desses termos pelo .NET.

No .NET (semelhante para Java):

• interfaces não podem ter estado ou implementação
• uma classe que implementa uma interface deve fornecer uma implementação de todos os métodos dessa interface
• classes abstratas podem conter estado (membros de dados) e / ou implementação (métodos)
• classes abstratas podem ser herdadas sem implementar os métodos abstratos (embora uma classe derivada seja a própria abstração)
• as interfaces podem ser herdadas por múltiplas classes, as abstratas podem não existir (esse é provavelmente o principal motivo concreto para as interfaces existirem separadamente das classes abtract - elas permitem uma implementação de herança múltipla que remove muitos dos problemas do MI geral).

Como termos gerais de OO, as diferenças não são necessariamente bem definidas. Por exemplo, existem programadores em C ++ que podem ter definições rígidas semelhantes (interfaces são um subconjunto estrito de classes abstratas que não podem conter implementação), enquanto alguns podem dizer que uma classe abstrata com algumas implementações padrão ainda é uma interface ou que não é abstrata A classe ainda pode definir uma interface.

De fato, existe um idioma C ++ chamado NVI (Interface Não Virtual), em que os métodos públicos são métodos não virtuais que 'otimizam' os métodos virtuais privados:

• http://www.gotw.ca/publications/mill18.htm
• http://en.wikibooks.org/wiki/More_C%2B%2B_Idioms/Non-Virtual_Interface

Que tal uma analogia: quando eu estava na Força Aérea, fui para o treinamento de pilotos e me tornei piloto da USAF (Força Aérea dos EUA). Naquele momento, eu não estava qualificado para pilotar nada, e tive que participar de treinamento do tipo aeronave. Depois de qualificado, fui piloto (classe abstrata) e C-141 (classe concreta). Em uma de minhas atribuições, recebi um dever adicional: oficial de segurança. Agora eu ainda era piloto e piloto C-141, mas também desempenhava funções de oficial de segurança (implementei o ISafetyOfficer, por assim dizer). Um piloto não era obrigado a ser um oficial de segurança, outras pessoas também poderiam ter feito isso.

Todos os pilotos da USAF devem seguir certos regulamentos de toda a Força Aérea, e todos os pilotos C-141 (ou F-16 ou T-38) 'são' pilotos da USAF. Qualquer um pode ser um oficial de segurança. Então, para resumir:

• Piloto: classe abstrata
• Piloto C-141: classe de concreto
• Oficial de segurança: interface

nota adicionada: isso deveria ser uma analogia para ajudar a explicar o conceito, não uma recomendação de codificação. Veja os vários comentários abaixo, a discussão é interessante.

Eu acho que a resposta que eles estão procurando é a diferença filosófica fundamental ou da OPPS.

A herança de classe abstrata é usada quando a classe derivada compartilha as principais propriedades e comportamento da classe abstrata. O tipo de comportamento que realmente define a classe.

Por outro lado, a herança de interface é usada quando as classes compartilham comportamentos periféricos, aqueles que não definem necessariamente a classe derivada.

Por exemplo. Um carro e um caminhão compartilham muitas propriedades e comportamentos essenciais de uma classe abstrata de automóvel, mas também compartilham algum comportamento periférico como Gerar escape, que até mesmo classes não automobilísticas, como Drillers ou PowerGenerators, compartilham e não definem necessariamente um carro ou caminhão , para que carro, caminhão, perfurador e PowerGenerator possam compartilhar a mesma interface IExhaust.

Breve: Classes abstratas são usadas para modelar uma hierarquia de classes de classes semelhantes (por exemplo, Animal pode ser classe abstrata e Human, Lion, Tiger podem ser classes derivadas concretas)

E

Interface é usada para Comunicação entre 2 classes similares / não semelhantes, que não se preocupam com o tipo de classe que implementa a Interface (por exemplo, Height pode ser propriedade da interface e pode ser implementado por Humanos, Edifícios, Árvores. Não importa se você pode comer , você pode nadar, pode morrer ou qualquer coisa .. isso importa apenas uma coisa que você precisa ter Height (implementação em sua classe)).

Existem algumas outras diferenças -

As interfaces não podem ter implementações concretas. As classes base abstratas podem. Isso permite que você forneça implementações concretas lá. Isso pode permitir que uma classe base abstrata forneça realmente um contrato mais rigoroso, enquanto uma interface realmente descreve apenas como uma classe é usada. (A classe base abstrata pode ter membros não virtuais que definem o comportamento, o que dá mais controle ao autor da classe base.)

Mais de uma interface pode ser implementada em uma classe. Uma classe só pode derivar de uma única classe base abstrata. Isso permite hierarquia polimórfica usando interfaces, mas não classes básicas abstratas. Isso também permite uma pseudo-herança múltipla usando interfaces.

As classes base abstratas podem ser modificadas na v2 + sem interromper a API. Mudanças nas interfaces estão quebrando as mudanças.

[C # /. NET Specific] As interfaces, diferentemente das classes base abstratas, podem ser aplicadas a tipos de valor (estruturas). Estruturas não podem herdar de classes base abstratas. Isso permite que os contratos comportamentais / diretrizes de uso sejam aplicados aos tipos de valor.

Herança
Considere um carro e um ônibus. Eles são dois veículos diferentes. Ainda assim, eles compartilham algumas propriedades comuns, como direção, freios, marchas, motor etc.
Portanto, com o conceito de herança, isso pode ser representado da seguinte forma ...

public class Vehicle {
    private Driver driver;
    private Seat[] seatArray; //In java and most of the Object Oriented Programming(OOP) languages, square brackets are used to denote arrays(Collections).
    //You can define as many properties as you want here ...
}

Agora uma bicicleta ...

public class Bicycle extends Vehicle {
    //You define properties which are unique to bicycles here ...
    private Pedal pedal;
}

E um carro ...

public class Car extends Vehicle {
    private Engine engine;
    private Door[] doors;
}

Isso é tudo sobre herança . Nós os usamos para classificar objetos em formas Base mais simples e seus filhos, como vimos acima.

Classes abstratas

Classes abstratas são objetos incompletos . Para entender melhor, vamos considerar a analogia do veículo mais uma vez.
Um veículo pode ser conduzido. Direita? Mas veículos diferentes são dirigidos de maneiras diferentes ... Por exemplo, você não pode dirigir um carro da mesma maneira que dirige uma bicicleta.
Então, como representar a função de direção de um veículo? É mais difícil verificar que tipo de veículo é e conduzi-lo com sua própria função; você precisaria alterar a classe Driver repetidamente ao adicionar um novo tipo de veículo.
Aí vem o papel das classes e métodos abstratos. Você pode definir o método da unidade como abstrato para informar que todos os filhos herdados devem implementar esta função.
Então, se você modificar a classe do veículo ...

//......Code of Vehicle Class
abstract public void drive();
//.....Code continues

A bicicleta e o carro também devem especificar como conduzi-lo. Caso contrário, o código não será compilado e um erro será gerado.
Em resumo .. uma classe abstrata é uma classe parcialmente incompleta com algumas funções incompletas, que os filhos herdados devem especificar por si próprios.

Interfaces As interfaces são totalmente incompletas. Eles não têm propriedades. Eles apenas indicam que os filhos herdados são capazes de fazer algo ...
Suponha que você tenha diferentes tipos de telefones celulares. Cada um deles tem maneiras diferentes de executar funções diferentes; Ex: ligue para uma pessoa. O fabricante do telefone especifica como fazê-lo. Aqui, os telefones celulares podem discar um número - ou seja, podem ser discados. Vamos representar isso como uma interface.

public interface Dialable {
    public void dial(Number n);
}

Aqui, o fabricante do Dialable define como discar um número. Você só precisa fornecer um número para discar.

// Makers define how exactly dialable work inside.

Dialable PHONE1 = new Dialable() {
    public void dial(Number n) {
        //Do the phone1's own way to dial a number
    }
}

Dialable PHONE2 = new Dialable() {
    public void dial(Number n) {
        //Do the phone2's own way to dial a number
    }
}


//Suppose there is a function written by someone else, which expects a Dialable
......
public static void main(String[] args) {
    Dialable myDialable = SomeLibrary.PHONE1;
    SomeOtherLibrary.doSomethingUsingADialable(myDialable);
}
.....

Por meio deste, usando interfaces em vez de classes abstratas, o gravador da função que usa um Dialable não precisa se preocupar com suas propriedades. Ex: possui tela sensível ao toque ou teclado de discagem. É um telefone fixo ou celular. Você só precisa saber se é discável; ele herda (ou implementa) a interface Dialable.

E o mais importante , se algum dia você trocar o Dialable por outro

......
public static void main(String[] args) {
    Dialable myDialable = SomeLibrary.PHONE2; // <-- changed from PHONE1 to PHONE2
    SomeOtherLibrary.doSomethingUsingADialable(myDialable);
}
.....

Você pode ter certeza de que o código ainda funciona perfeitamente porque a função que usa a discagem não depende (e não pode) depender de outros detalhes além dos especificados na interface Discável. Ambos implementam uma interface Dialable e essa é a única coisa com a qual a função se importa.

As interfaces são comumente usadas pelos desenvolvedores para garantir a interoperabilidade (uso intercambiável) entre objetos, na medida em que compartilham uma função comum (assim como você pode mudar para um telefone fixo ou celular, na medida em que você só precisa discar um número). Em resumo, as interfaces são uma versão muito mais simples das classes abstratas, sem propriedades.
Além disso, observe que você pode implementar (herdar) quantas interfaces desejar, mas só pode estender (herdar) uma única classe-pai.

Mais informações Classes abstratas vs interfaces

Se você considerar a javalinguagem OOP para responder a essa pergunta, a liberação do Java 8 fará com que parte do conteúdo das respostas acima seja obsoleta. Agora a interface java pode ter métodos padrão com implementação concreta.

O site da Oracle fornece as principais diferenças entre interfacee abstractclasse.

Considere usar classes abstratas se:

1. Você deseja compartilhar código entre várias classes estreitamente relacionadas.
2. Você espera que as classes que estendem sua classe abstrata tenham muitos métodos ou campos comuns ou exijam modificadores de acesso que não sejam públicos (como protegido e privado).
3. Você deseja declarar campos não estáticos ou não finais.

Considere usar interfaces se:

1. Você espera que classes não relacionadas implementem sua interface. Por exemplo, muitos objetos não relacionados podem implementar a Serializableinterface.
2. Você deseja especificar o comportamento de um tipo de dados específico, mas não se preocupa com quem implementa seu comportamento.
3. Você deseja tirar proveito da herança múltipla do tipo.

Em termos simples, eu gostaria de usar

Interface: Para implementar um contrato por vários objetos não relacionados

classe abstrata: Para implementar o mesmo ou diferente comportamento entre vários objetos relacionados

Dê uma olhada no exemplo de código para entender as coisas de maneira clara: como eu deveria ter explicado a diferença entre uma interface e uma classe abstrata?

Os entrevistadores estão latindo para uma árvore estranha. Para linguagens como C # e Java, há uma diferença, mas em outras linguagens como C ++ não há. A teoria OO não diferencia os dois, apenas a sintaxe da linguagem.

Uma classe abstrata é uma classe com implementação e interface (métodos virtuais puros) que serão herdadas. As interfaces geralmente não têm nenhuma implementação, mas apenas funções virtuais puras.

Em C # ou Java, uma classe abstrata sem implementação difere de uma interface apenas na sintaxe usada para herdar dela e no fato de que você só pode herdar de uma.

Ao implementar interfaces, você obtém composição (relacionamentos "has-a") em vez de herança (relacionamentos "is-a"). Esse é um princípio importante a ser lembrado quando se trata de padrões de design nos quais você precisa usar interfaces para obter uma composição de comportamentos em vez de uma herança.

explicarei os detalhes da profundidade da interface e da classe abstrata. Se você conhece uma visão geral sobre interface e classe abstrata, a primeira pergunta vem à sua mente quando devemos usar a interface e quando devemos usar a classe abstrata. Portanto, verifique abaixo a explicação da interface e da classe Abstract.

1. Quando devemos usar a interface?

   se você não conhece a implementação, apenas temos especificações de requisitos, seguimos com a Interface

2. Quando devemos usar a classe abstrata?

   se você conhece a implementação, mas não completamente (parcialmente), seguimos com a classe Abstract.

   Interface

   todo método por padrão abstrato público significa que a interface é 100% pura abstrata.

   Resumo

   pode ter o método Concrete e o Abstract, o que é o método Concrete, que tem implementação na classe Abstract. Uma classe abstract é uma classe declarada abstrata - pode ou não incluir métodos abstratos.

   Interface

   Não podemos declarar a interface como privada, protegida

   P. Por que não estamos declarando a Interface como privada e protegida?

   Porque, por padrão, o método da interface é abstrato público, portanto, e por isso, não declaramos a interface como privada e protegida.

   Método de interface
   também não podemos declarar interface como privada, protegida, final, estática, sincronizada, nativa .....

   darei o motivo: por que não estamos declarando o método sincronizado porque não podemos criar objeto de interface e sincronizar são trabalhos no objeto, e por isso não estamos declarando o método sincronizado O conceito transiente também não é aplicável porque o trabalho transitório com sincronizado.

   Resumo

   felizmente usamos com estática final pública e privada .... significa que nenhuma restrição é aplicável em abstrato.

   Interface

   As variáveis ​​são declaradas na Interface como uma final estática pública por padrão, portanto, também não somos declaradas variáveis ​​como privadas, protegidas.

   O modificador volátil também não é aplicável na interface, porque a variável de interface é, por padrão, estática pública final e variável final. Você não pode alterar o valor depois que ele atribui o valor à variável e depois de declarar variável na interface, é necessário atribuir a variável.

   E a variável volátil é manter as alterações, por isso é opp. Para finalizar, é por isso que não usamos variáveis ​​voláteis na interface.

   Resumo

   Variável abstrata sem necessidade de declarar final estático público.

Espero que este artigo seja útil.

Conceitualmente falando, mantendo a implementação específica da linguagem, regras, benefícios e atingindo qualquer objetivo de programação usando qualquer um ou ambos, pode ou não pode ter código / dados / propriedade, blá blá, heranças únicas ou múltiplas, tudo de lado

1- Resumo (ou resumo puro) A classe visa implementar a hierarquia. Se seus objetos de negócios parecerem estruturalmente semelhantes, representando apenas um tipo de relacionamento pai-filho (hierarquia), as classes de herança / Resumo serão usadas. Se o seu modelo de negócios não tiver uma hierarquia, a herança não deve ser usada (aqui não estou falando sobre lógica de programação, por exemplo, alguns padrões de design requerem herança). Conceitualmente, a classe abstrata é um método para implementar a hierarquia de um modelo de negócios no OOP, não tem nada a ver com interfaces, na verdade, comparar a classe abstrata com a interface não faz sentido porque ambas são coisas conceitualmente totalmente diferentes, isso é solicitado em entrevistas apenas para verificar os conceitos, pois parece que eles fornecem a mesma funcionalidade no que diz respeito à implementação e nós programadores geralmente enfatizam mais a codificação. [Lembre-se disso também de que Abstração é diferente da Classe Abstrata].

2 - Uma interface é um contrato, uma funcionalidade comercial completa representada por um ou mais conjuntos de funções. É por isso que é implementado e não herdado. Um objeto de negócios (parte de uma hierarquia ou não) pode ter qualquer número de funcionalidades completas de negócios. Não tem nada a ver com classes abstratas, significa herança em geral. Por exemplo, um humano pode EXECUTAR, um elefante pode EXECUTAR, um pássaro pode EXECUTAR e assim por diante, todos esses objetos de hierarquia diferente implementariam a interface EXECUTAR ou a interface COMER ou FALAR. Não entre na implementação, pois você pode implementá-la como tendo classes abstratas para cada tipo que implementa essas interfaces. Um objeto de qualquer hierarquia pode ter uma funcionalidade (interface) que não tem nada a ver com sua hierarquia.

Acredito que as interfaces não foram inventadas para obter várias heranças ou expor o comportamento do público, e da mesma forma, as classes abstratas puras não substituem as interfaces, mas Interface é uma funcionalidade que um objeto pode fazer (por meio de funções dessa interface) e a Abstract Class representa um pai de uma hierarquia para produzir filhos com estrutura principal (propriedade + funcionalidade) do pai

Quando você é questionado sobre a diferença, na verdade, é diferença conceitual, não a diferença na implementação específica do idioma, a menos que seja solicitado explicitamente.

Acredito que os dois entrevistadores esperavam uma diferença direta de uma linha entre esses dois e, quando você falhou, eles tentaram levá-lo a essa diferença implementando UM como o OUTRO

E se você tivesse uma classe Abstract com apenas métodos abstratos?

Para .Net,

Sua resposta para o segundo entrevistador também é a resposta para o primeiro ... As classes abstratas podem ter implementação E estado, as interfaces não podem ...

EDIT: Em outra nota, eu nem usaria a frase 'subclasse' (ou a frase 'herança') para descrever classes que são 'definidas para implementar' uma interface. Para mim, uma interface é uma definição de contrato com o qual uma classe deve estar em conformidade se tiver sido definida para 'implementar' essa interface. Não herda nada ... Você precisa adicionar tudo explicitamente.

Interface : deve ser usada se você deseja sugerir uma regra nos componentes que podem ou não estar relacionados entre si

Prós:

1. Permite herança múltipla
2. Fornece abstração não expondo que tipo exato de objeto está sendo usado no contexto
3. fornece consistência mediante uma assinatura específica do contrato

Contras:

1. Deve implementar todos os contratos definidos
2. Não pode ter variáveis ​​ou delegados
3. Uma vez definido, não pode ser alterado sem quebrar todas as classes

Classe abstrata : deve ser usada onde você deseja ter algum comportamento ou implementação básica ou padrão para componentes relacionados entre si

Prós:

1. Mais rápido que a interface
2. Possui flexibilidade na implementação (você pode implementá-lo total ou parcialmente)
3. Pode ser facilmente alterado sem interromper as classes derivadas

Contras:

1. Não pode ser instanciado
2. Não suporta herança múltipla

Eu acho que eles não gostaram da sua resposta porque você deu as diferenças técnicas em vez das de design. A pergunta é como uma pergunta troll para mim. De fato, interfaces e classes abstratas têm uma natureza completamente diferente, portanto você não pode realmente compará-las. Darei a você minha visão sobre qual é o papel de uma interface e qual é o papel de uma classe abstrata.

interface: é usada para garantir um contrato e fazer um baixo acoplamento entre as classes, a fim de ter uma aplicação mais sustentável, escalável e testável.

classe abstrata: é usada apenas para fatorar algum código entre classes da mesma responsabilidade. Observe que esse é o principal motivo pelo qual a herança múltipla é uma coisa ruim no OOP, porque uma classe não deve lidar com muitas responsabilidades (use a composição ).

Portanto, as interfaces têm um papel arquitetural real, enquanto as classes abstratas são quase apenas um detalhe de implementação (se você a usar corretamente, é claro).

After all that, the interviewer came up with the question "What if you had an 
Abstract class with only abstract methods? How would that be different
from an interface?" 

Os documentos dizem claramente que, se uma classe abstrata contiver apenas declarações de método abstrato, ela deverá ser declarada como uma interface.

An another interviewer asked me what if you had a Public variable inside
the interface, how would that be different than in Abstract Class?

As variáveis ​​nas interfaces são, por padrão, estáticas e finais públicas. A pergunta poderia ser estruturada como se todas as variáveis ​​da classe abstrata fossem públicas? Bem, eles ainda podem ser não estáticos e não finais, diferentemente das variáveis ​​nas interfaces.

Finalmente, eu acrescentaria mais um ponto aos mencionados acima - as classes abstratas ainda são classes e se enquadram em uma única árvore de herança, enquanto as interfaces podem estar presentes em várias heranças.

1. Interface:
   • Nós não implementamos (ou definimos) métodos, fazemos isso em classes derivadas.
   • Não declaramos variáveis ​​de membro em interfaces.
   • As interfaces expressam o relacionamento HAS-A. Isso significa que eles são uma máscara de objetos.
2. Classe abstrata:
   • Podemos declarar e definir métodos na classe abstrata.
   • Escondemos construtores disso. Isso significa que não há objeto criado diretamente a partir dele.
   • A classe abstrata pode conter variáveis ​​de membro.
   • Classes derivadas herdam a classe abstrata que significam que objetos de classes derivadas não são mascaradas, mas herdam a classe abstrata. O relacionamento neste caso é IS-A.

Esta é a minha opinião.

Copiado do CLR via C # por Jeffrey Richter ...

Frequentemente ouço a pergunta: "Devo criar um tipo de base ou uma interface?" A resposta nem sempre é clara.

Aqui estão algumas diretrizes que podem ajudá-lo:

■■ Relacionamento IS-A vs. CAN-DO Um tipo pode herdar apenas uma implementação. Se o tipo derivado não puder reivindicar um relacionamento IS-A com o tipo base, não use um tipo base; use uma interface. As interfaces implicam um relacionamento CAN-DO. Se a funcionalidade CAN-DO parecer pertencer a vários tipos de objetos, use uma interface. Por exemplo, um tipo pode converter instâncias de si mesmo para outro tipo (IConvertible), um tipo pode serializar uma instância de si mesmo (ISerializable) etc. Observe que os tipos de valor devem ser derivados de System.ValueType e, portanto, não podem ser derivados de uma classe base arbitrária. Nesse caso, você deve usar um relacionamento CAN-DO e definir uma interface.

■■ Facilidade de uso Geralmente, é mais fácil para você, como desenvolvedor, definir um novo tipo derivado de um tipo base do que implementar todos os métodos de uma interface. O tipo base pode fornecer muitas funcionalidades; portanto, o tipo derivado provavelmente precisa apenas de modificações relativamente pequenas em seu comportamento. Se você fornecer uma interface, o novo tipo deverá implementar todos os membros.

■■ Implementação consistente Não importa o quão bem um contrato de interface esteja documentado, é muito improvável que todos implementem o contrato 100% corretamente. De fato, o COM sofre desse mesmo problema, e é por isso que alguns objetos COM funcionam corretamente apenas com o Microsoft Word ou com o Windows Internet Explorer. Ao fornecer um tipo de base com uma boa implementação padrão, você começa a usar um tipo que funciona e é bem testado; você pode modificar as peças que precisam de modificação.

■■ Controle de versão Se você adicionar um método ao tipo base, o tipo derivado herdará o novo método, você começará a usar um tipo que funcione e o código-fonte do usuário nem precisará ser recompilado. A adição de um novo membro a uma interface força o herdeiro da interface a alterar seu código-fonte e a recompilar.

Uma interface define um contrato para um serviço ou conjunto de serviços. Eles fornecem polimorfismo de maneira horizontal, no sentido de que duas classes completamente independentes podem implementar a mesma interface, mas podem ser usadas alternadamente como parâmetro do tipo de interface que implementam, pois ambas as classes prometeram satisfazer o conjunto de serviços definido pela interface. As interfaces não fornecem detalhes de implementação.

Uma classe abstrata define uma estrutura base para suas subcategorias e, opcionalmente, implementação parcial. As classes abstratas fornecem polimorfismo de maneira vertical, mas direcional, em que qualquer classe que herda a classe abstrata pode ser tratada como uma instância dessa classe abstrata, mas não o contrário. As classes abstratas podem e geralmente contêm detalhes de implementação, mas não podem ser instanciadas por si próprias - apenas suas subclasses podem ser "atualizadas".

O C # também permite a herança da interface, lembre-se.

A maioria das respostas se concentra na diferença técnica entre Classe Abstrata e Interface, mas, tecnicamente, uma interface é basicamente um tipo de classe abstrata (uma sem dados ou implementação), acho que a diferença conceitual é muito mais interessante e pode ser o que os entrevistadores estão atrás.

Uma interface é um acordo . Ele especifica: "é assim que vamos conversar". Ele não pode ter nenhuma implementação porque não deveria ter nenhuma implementação. É um contrato. É como os .harquivos de cabeçalho em C.

Uma classe abstrata é uma implementação incompleta . Uma classe pode ou não implementar uma interface e uma classe abstrata não precisa implementá-la completamente. Uma classe abstrata sem qualquer implementação é meio inútil, mas totalmente legal.

Basicamente, qualquer classe, abstrata ou não, é sobre o que é , enquanto uma interface é sobre como você a usa . Por exemplo: Animalpode ser uma classe abstrata implementando algumas funções metabólicas básicas e especificando métodos abstratos para respiração e locomoção sem dar uma implementação, porque não tem idéia se deve respirar através de brânquias ou pulmões e se voa, nada, caminha ou rasteja. Mount, por outro lado, pode ser uma interface, que especifica que você pode montar no animal, sem saber que tipo de animal é (ou se é um animal!).

O fato de que nos bastidores, uma interface é basicamente uma classe abstrata com apenas métodos abstratos, não importa. Conceitualmente, eles cumprem papéis totalmente diferentes.

Como você pode ter adquirido o conhecimento teórico dos especialistas, não estou gastando muito em repetir tudo isso aqui, mas deixe-me explicar com um exemplo simples de onde podemos usar / não podemos usar Interfacee Abstract class.

Considere que você está criando um aplicativo para listar todos os recursos do Cars. Em vários pontos, você precisa de herança em comum, pois algumas das propriedades como DigitalFuelMeter, Ar condicionado, ajuste de assento, etc. são comuns para todos os carros. Da mesma forma, precisamos de herança para algumas classes apenas porque algumas das propriedades, como o sistema de freio (ABS, EBD), são aplicáveis ​​apenas a alguns carros.

A classe abaixo atua como uma classe base para todos os carros:

public class Cars
{
    public string DigitalFuelMeter()
    {
        return "I have DigitalFuelMeter";
    }

    public string AirCondition()
    {
        return "I have AC";
    }

    public string SeatAdjust()
    {
        return "I can Adjust seat";
    }
}

Considere que temos uma classe separada para cada carro.

public class Alto : Cars
{
    // Have all the features of Car class    
}

public class Verna : Cars
{
    // Have all the features of Car class + Car need to inherit ABS as the Braking technology feature which is not in Cars        
}

public class Cruze : Cars
{
    // Have all the features of Car class + Car need to inherit EBD as the Braking technology feature which is not in Cars        
}

Considere que precisamos de um método para herdar a tecnologia de frenagem dos carros Verna e Cruze (não aplicável ao Alto). Embora ambos usem a tecnologia de frenagem, a "tecnologia" é diferente. Portanto, estamos criando uma classe abstrata na qual o método será declarado como Resumo e deve ser implementado em suas classes filho.

public abstract class Brake
{
    public abstract string GetBrakeTechnology();
}

Agora, estamos tentando herdar dessa classe abstrata e o tipo de sistema de frenagem é implementado em Verna e Cruze:

public class Verna : Cars,Brake
{
    public override string GetBrakeTechnology()
    {
        return "I use ABS system for braking";
    }       
}

public class Cruze : Cars,Brake
{
    public override string GetBrakeTechnology()
    {
       return "I use EBD system for braking";
    }         
}

Veja o problema nas duas classes acima? Eles herdam de várias classes que o C # .Net não permite, mesmo que o método seja implementado nos filhos. Aí vem a necessidade de interface.

interface IBrakeTechnology
{
    string GetBrakeTechnology();
}

E a implementação é dada abaixo:

public class Verna : Cars, IBrakeTechnology
{
    public string GetBrakeTechnology()
    {
        return "I use ABS system for braking";
    }
}

public class Cruze : Cars, IBrakeTechnology
{
   public string GetBrakeTechnology()
   {
       return "I use EBD system for braking";
   }        
}

Agora Verna e Cruze podem obter herança múltipla com seu próprio tipo de tecnologias de frenagem com a ajuda da Interface.

As interfaces são uma maneira leve de impor um comportamento específico. Essa é uma maneira de pensar.

Essas respostas são longas demais.

• As interfaces são para definir comportamentos.

• As classes abstratas são para definir uma coisa em si, incluindo seus comportamentos. É por isso que às vezes criamos uma classe abstrata com algumas propriedades extras que herdam uma interface.

Isso também explica por que o Java suporta apenas herança única para classes, mas não restringe as interfaces. Porque um objeto concreto não pode ser diferente, mas pode ter comportamentos diferentes.

1) Uma interface pode ser vista como uma classe abstrata pura, é a mesma, mas, apesar disso, não é a mesma coisa para implementar uma interface e herdar de uma classe abstrata. Quando você herda desta classe abstrata pura, está definindo uma hierarquia -> herança, se implementar a interface que não é e pode implementar quantas interfaces quiser, mas só pode herdar de uma classe.

2) Você pode definir uma propriedade em uma interface, portanto, a classe que implementa essa interface deve ter essa propriedade.

Por exemplo:

  public interface IVariable
  {
      string name {get; set;}
  }

A classe que implementa essa interface deve ter uma propriedade como essa.

Embora essa pergunta seja bastante antiga, gostaria de acrescentar outro ponto a favor das interfaces:

As interfaces podem ser injetadas usando qualquer ferramenta de Injeção de Dependência, onde, como injeção de classe Abstrata, é suportada por muito poucas.

De outra resposta minha , lidando principalmente com quando usar uma contra a outra:

Na minha experiência, as interfaces são melhor usadas quando você tem várias classes, cada uma delas precisa responder ao mesmo método ou métodos, para que possam ser usadas de forma intercambiável por outro código que será escrito na interface comum dessas classes. O melhor uso de uma interface é quando o protocolo é importante, mas a lógica subjacente pode ser diferente para cada classe. Se você estiver duplicando a lógica, considere classes abstratas ou herança de classe padrão.

Tipos de interface versus classes base abstratas

Adaptado do Pro C # 5.0 e do livro do .NET 4.5 Framework .

O tipo de interface pode parecer muito semelhante a uma classe base abstrata. Lembre-se de que quando uma classe é marcada como abstrata, ela pode definir qualquer número de membros abstratos para fornecer uma interface polimórfica para todos os tipos derivados. No entanto, mesmo quando uma classe define um conjunto de membros abstratos, também é livre definir qualquer número de construtores, dados de campo, membros não abstratos (com implementação) e assim por diante. As interfaces, por outro lado, contêm apenas definições de membros abstratas. A interface polimórfica estabelecida por uma classe pai abstrata sofre de uma limitação principal, pois apenas tipos derivados suportam os membros definidos pelo pai abstrato. No entanto, em sistemas de software maiores, é muito comum o desenvolvimento de várias hierarquias de classes que não possuem pai comum além do System.Object. Dado que membros abstratos em uma classe base abstrata se aplicam apenas a tipos derivados, não temos como configurar tipos em hierarquias diferentes para suportar a mesma interface polimórfica. A título de exemplo, suponha que você tenha definido a seguinte classe abstrata:

public abstract class CloneableType
{
// Only derived types can support this
// "polymorphic interface." Classes in other
// hierarchies have no access to this abstract
// member.
   public abstract object Clone();
}

Dada essa definição, apenas membros que estendem o CloneableType podem oferecer suporte ao método Clone (). Se você criar um novo conjunto de classes que não estenda essa classe base, não poderá obter essa interface polimórfica. Além disso, você deve se lembrar que o C # não suporta herança múltipla para classes. Portanto, se você deseja criar um MiniVan que é um carro e é um CloneableType, não será possível:

// Nope! Multiple inheritance is not possible in C#
// for classes.
public class MiniVan : Car, CloneableType
{
}

Como você poderia imaginar, os tipos de interface são úteis. Após a definição de uma interface, ela pode ser implementada por qualquer classe ou estrutura, em qualquer hierarquia, em qualquer espaço de nome ou assembly (gravado em qualquer linguagem de programação .NET). Como você pode ver, as interfaces são altamente polimórficas. Considere a interface .NET padrão chamada ICloneable, definida no espaço para nome do sistema. Essa interface define um único método chamado Clone ():

public interface ICloneable
{
object Clone();
}

Resposta à segunda pergunta: a publicvariável definida em interfaceé static finalpor padrão, enquanto a publicvariável na abstractclasse é uma variável de instância.

Com certeza é importante entender o comportamento da interface e da classe abstrata no OOP (e como as linguagens os lidam), mas acho que também é importante entender o que exatamente cada termo significa. Você pode imaginar o ifcomando não funcionando exatamente como o significado do termo? Além disso, na verdade, algumas linguagens estão reduzindo, ainda mais, as diferenças entre uma interface e um resumo ... se por um dia os dois termos operam quase de forma idêntica, pelo menos você pode se definir onde (e por que) alguma delas deve estar usado para.

Se você ler alguns dicionários e outras fontes, poderá encontrar significados diferentes para o mesmo termo, mas com algumas definições comuns. Acho que esses dois significados que encontrei neste site são muito, muito bons e adequados.

Interface:

Uma coisa ou circunstância que permite que elementos separados e às vezes incompatíveis se coordenem efetivamente.

Resumo:

Algo que concentra em si as qualidades essenciais de qualquer coisa mais extensa ou mais geral, ou de várias coisas; essência.

Exemplo:

Você comprou um carro e ele precisa de combustível.

O modelo do seu carro é XYZ, que é de gênero ABC, por isso é um carro de concreto, uma instância específica de um carro. Um carro não é um objeto real. De fato, é um conjunto abstrato de padrões (qualidades) para criar um objeto específico. Em suma, Car é uma classe abstrata , é "algo que concentra em si as qualidades essenciais de qualquer coisa mais extensa ou mais geral" .

O único combustível que corresponde à especificação manual do carro deve ser usado para encher o tanque do carro. Na realidade, não há nada para restringir você a colocar combustível, mas o motor funcionará corretamente apenas com o combustível especificado, portanto, é melhor seguir seus requisitos. Os requisitos dizem que ele aceita, como outros carros do mesmo gênero ABC, um conjunto padrão de combustível.

Em uma visão orientada a objetos, o combustível para o gênero ABCnão deve ser declarado como uma classe, porque não há combustível concreto para um gênero específico de carro por aí. Embora seu carro possa aceitar uma classe abstrata Fuel ou VeicularFuel, lembre-se de que apenas parte do combustível veicular existente atende às especificações, aquelas que implementam os requisitos do manual do carro. Em resumo, eles devem implementar a interface ABCGenreFuel , que "... permite que elementos separados e às vezes incompatíveis sejam coordenados de maneira eficaz" .

Termo aditivo

Além disso, acho que você deve ter em mente o significado do termo classe, que é (do mesmo site mencionado anteriormente):

Classe:

Várias pessoas ou coisas consideradas como formando um grupo devido a atributos, características, qualidades ou características comuns; tipo;

Dessa forma, uma classe (ou classe abstrata) não deve representar apenas atributos comuns (como uma interface), mas algum tipo de grupo com atributos comuns. Uma interface não precisa representar um tipo. Ele deve representar atributos comuns. Dessa forma, acho que classes e classes abstratas podem ser usadas para representar coisas que não devem mudar seus aspectos com frequência, como um ser humano um mamífero, porque representa alguns tipos. Os tipos não devem mudar a si mesmos com tanta frequência.

Da perspectiva da codificação

Uma interface pode substituir uma classe abstrata se a classe abstrata tiver apenas métodos abstratos. Caso contrário, alterar a classe Abstract para interface significa que você estará perdendo a reutilização do código que a Herança fornece.

Da perspectiva do design

Mantenha-o como uma classe abstrata se for um relacionamento "É um" e você precisar de um subconjunto ou de todas as funcionalidades. Mantenha-o como Interface se for um relacionamento "Deveria fazer".

Decida o que você precisa: apenas a aplicação da política ou reutilização do código E política.

Algumas outras diferenças:

As classes abstratas podem ter métodos estáticos, propriedades, campos etc. e operadores, interfaces não. O operador Cast permite converter de / para a classe abstrata, mas não permite converter de / para a interface.

Portanto, você pode usar a classe abstrata por si própria, mesmo que nunca seja implementada (por meio de seus membros estáticos) e não pode usar a interface por si só de nenhuma maneira.