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

Interfaces

Uma interface é um contrato : a pessoa que escreve a interface diz: " ei, eu aceito as coisas dessa maneira ", e a pessoa que usa a interface diz " OK, a classe que escrevo parece dessa maneira ".

Uma interface é um shell vazio . Existem apenas as assinaturas dos métodos, o que implica que os métodos não têm um corpo. A interface não pode fazer nada. É apenas um padrão.

Por exemplo (pseudo código):

// I say all motor vehicles should look like this:
interface MotorVehicle
{
    void run();

    int getFuel();
}

// My team mate complies and writes vehicle looking that way
class Car implements MotorVehicle
{

    int fuel;

    void run()
    {
        print("Wrroooooooom");
    }


    int getFuel()
    {
        return this.fuel;
    }
}

A implementação de uma interface consome muito pouca CPU, porque não é uma classe, apenas um monte de nomes e, portanto, não há nenhuma pesquisa cara a fazer. É ótimo quando importa, como em dispositivos incorporados.

Classes abstratas

Classes abstratas, diferentemente das interfaces, são classes. Eles são mais caros de usar, porque há uma pesquisa a fazer quando você os herda.

As classes abstratas se parecem muito com interfaces, mas têm algo mais: você pode definir um comportamento para elas. É mais sobre uma pessoa dizendo: " essas classes devem ser assim, e elas têm isso em comum, então preencha os espaços em branco! ".

Por exemplo:

// I say all motor vehicles should look like this:
abstract class MotorVehicle
{

    int fuel;

    // They ALL have fuel, so lets implement this for everybody.
    int getFuel()
    {
         return this.fuel;
    }

    // That can be very different, force them to provide their
    // own implementation.
    abstract void run();
}

// My teammate complies and writes vehicle looking that way
class Car extends MotorVehicle
{
    void run()
    {
        print("Wrroooooooom");
    }
}

Implementação

Embora classes e interfaces abstratas devam ser conceitos diferentes, as implementações tornam essa declaração às vezes falsa. Às vezes, eles nem são o que você pensa que são.

Em Java, essa regra é fortemente aplicada, enquanto no PHP, as interfaces são classes abstratas sem nenhum método declarado.

No Python, as classes abstratas são mais um truque de programação que você pode obter do módulo ABC e, na verdade, está usando metaclasses e, portanto, classes. E as interfaces estão mais relacionadas à digitação com duck nesta linguagem e é uma mistura entre convenções e métodos especiais que chamam descritores (os métodos __method__).

Como de costume na programação, há teoria, prática e prática em outro idioma :-)

As principais diferenças técnicas entre uma classe abstrata e uma interface são:

• As classes abstratas podem ter constantes, membros, stubs de métodos (métodos sem um corpo) e métodos definidos , enquanto as interfaces podem ter apenas stubs de constantes e métodos .

• Métodos e membros de uma classe abstrata podem ser definidos com qualquer visibilidade , enquanto todos os métodos de uma interface devem ser definidos como public(eles são definidos como públicos por padrão).

• Ao herdar uma classe abstrata, uma classe filha concreta deve definir os métodos abstratos , enquanto uma classe abstrata pode estender outra classe abstrata e os métodos abstratos da classe pai não precisam ser definidos.

• Da mesma forma, uma interface que estende outra interface não é responsável por implementar métodos da interface pai. Isso ocorre porque as interfaces não podem definir nenhuma implementação.

• Uma classe filho pode estender apenas uma única classe (abstrata ou concreta), enquanto uma interface pode estender ou uma classe pode implementar várias outras interfaces .

• Uma classe filha pode definir métodos abstratos com a mesma visibilidade ou menos restritiva , enquanto uma classe que implementa uma interface deve definir os métodos com a mesma visibilidade exata (pública).

Uma interface contém apenas a definição / assinatura de funcionalidade e, se tivermos alguma funcionalidade comum, além de assinaturas comuns, precisamos usar uma classe abstrata. Usando uma classe abstrata, podemos fornecer comportamento e funcionalidade ao mesmo tempo. Outro desenvolvedor que herda a classe abstrata pode usar essa funcionalidade facilmente, pois precisaria preencher apenas os espaços em branco.

Tirado de:

http://www.dotnetbull.com/2011/11/difference-between-abstract-class-and.html

http://www.dotnetbull.com/2011/11/what-is-abstract-class-in-c-net.html http://www.dotnetbull.com/2011/11/what-is-interface-in -c-net.html

Uma explicação pode ser encontrada aqui: http://www.developer.com/lang/php/article.php/3604111/PHP-5-OOP-Interfaces-Abstract-Classes-and-the-Adapter-Pattern.htm

Uma classe abstrata é uma classe que é implementada apenas parcialmente pelo programador. Pode conter um ou mais métodos abstratos. Um método abstrato é simplesmente uma definição de função que serve para informar ao programador que o método deve ser implementado em uma classe filho.

Uma interface é semelhante a uma classe abstrata; de fato, as interfaces ocupam o mesmo espaço para nome das classes e classes abstratas. Por esse motivo, você não pode definir uma interface com o mesmo nome que uma classe. Uma interface é uma classe totalmente abstrata; nenhum de seus métodos é implementado e, em vez de uma classe subclassificada, é dito que implementa essa interface.

Enfim, acho essa explicação de interfaces um pouco confusa. Uma definição mais comum é: Uma interface define um contrato que as classes de implementação devem cumprir. Uma definição de interface consiste em assinaturas de membros públicos, sem nenhum código de implementação.

Não quero destacar as diferenças, que já foram ditas em muitas respostas (sobre modificadores finais estáticos públicos para variáveis ​​na interface e suporte a métodos privados e protegidos em classes abstratas)

Em termos simples, eu gostaria de dizer:

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

Na documentação do Oracle

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.

classe abstrata estabelece "é uma" relação com classes concretas. interface fornece "possui um" recurso para classes.

Se você procura Javacomo linguagem de programação, aqui estão mais algumas atualizações:

O Java 8 reduziu a diferença entre classes interfacee abstract, em certa medida, fornecendo um defaultrecurso de método. Uma interface não possui uma implementação para um método não é mais válida agora.

Consulte esta página de documentação para obter mais detalhes.

Dê uma olhada nesta pergunta SE para obter exemplos de código para entender melhor.

Como devo ter explicado a diferença entre uma interface e uma classe abstrata?

Algumas diferenças importantes:

Sob a forma de uma tabela:

Como afirma Joe de javapapers :

1.A principal diferença é que os métodos de uma interface Java são implicitamente abstratos e não podem ter implementações. Uma classe abstrata Java pode ter métodos de instância que implementam um comportamento padrão.

2.As variáveis ​​declaradas em uma interface Java são, por padrão, finais. Uma classe abstrata pode conter variáveis ​​não finais.

3.Os membros de uma interface Java são públicos por padrão. Uma classe abstrata Java pode ter os sabores usuais dos membros da classe, como privado, protegido, etc.

4. A interface Java deve ser implementada usando a palavra-chave “implementa”; Uma classe abstrata Java deve ser estendida usando a palavra-chave “extends”.

5.Uma interface pode estender apenas outra interface Java, uma classe abstrata pode estender outra classe Java e implementar várias interfaces Java.

6. Uma classe Java pode implementar várias interfaces, mas pode estender apenas uma classe abstrata.

7.Interface é absolutamente abstrato e não pode ser instanciado; Uma classe abstrata Java também não pode ser instanciada, mas pode ser chamada se existir um main ().

8.Em comparação com as classes abstratas java, as interfaces java são lentas, pois requerem uma indireção extra.

O ponto principal é que:

• Resumo é orientado a objetos . Ele oferece os dados básicos que um 'objeto' deve ter e / ou funções que deve poder executar. Diz respeito às características básicas do objeto: o que ele tem e o que pode fazer. Portanto, objetos que herdam da mesma classe abstrata compartilham as características básicas (generalização).
• A interface é orientada à funcionalidade . Ele define as funcionalidades que um objeto deve ter. Independentemente de qual objeto seja, desde que ele possa executar essas funcionalidades, definidas na interface, tudo bem. Ignora tudo o resto. Um objeto / classe pode conter várias (grupos de) funcionalidades; portanto, é possível que uma classe implemente várias interfaces.

Quando você deseja fornecer um comportamento polimórfico em uma hierarquia de herança, use classes abstratas.

Quando você quiser um comportamento polimórfico para classes completamente não relacionadas, use uma interface.

Estou construindo um prédio de 300 andares

A interface de planta do edifício

• Por exemplo, Servlet (I)

Edifício construído até 200 andares - parcialmente concluído --- resumo

• Implementação parcial, por exemplo, servlet genérico e HTTP

Construção civil concluída - concreto

• Implementação completa, por exemplo, próprio servlet

Interface

• Não sabemos nada sobre implementação, apenas requisitos. Nós podemos ir para uma interface.
• Todo método é público e abstrato por padrão
• É uma classe abstrata 100% pura
• Se declararmos público, não podemos declarar privado e protegido
• Se declaramos abstrato, não podemos declarar final, estático, sincronizado, strictfp e nativo
• Toda interface possui público, estático e final
• Serialização e transitório não são aplicáveis, porque não podemos criar uma instância para na interface
• Não volátil porque é final
• Toda variável é estática
• Quando declaramos uma variável dentro de uma interface, precisamos inicializar variáveis ​​enquanto declara
• Instância e bloco estático não permitidos

Resumo

• Implementação parcial
• Tem um método abstrato. Além disso, utiliza concreto
• Nenhuma restrição para modificadores de método de classe abstrata
• Nenhuma restrição para modificadores de variáveis ​​de classe abstrata
• Não podemos declarar outros modificadores, exceto abstract
• Nenhuma restrição para inicializar variáveis

Retirado do site DurgaJobs

Vamos trabalhar nessa questão novamente:

A primeira coisa a informar é que 1/1 e 1 * 1 resultam da mesma forma, mas isso não significa que multiplicação e divisão sejam iguais. Obviamente, eles mantêm um bom relacionamento, mas lembre-se de que ambos são diferentes.

Vou apontar as principais diferenças e o restante já foi explicado:

Classes abstratas são úteis para modelar uma hierarquia de classes. À primeira vista de qualquer requisito, somos parcialmente claros sobre o que exatamente deve ser construído, mas sabemos o que construir.E assim suas classes abstratas são suas classes base.

As interfaces são úteis para permitir que outras hierarquias ou classes saibam o que eu sou capaz de fazer. E quando você diz que sou capaz de algo, você deve ter essa capacidade. As interfaces marcarão como obrigatório para uma classe implementar as mesmas funcionalidades.

É bem simples, na verdade.

Você pode pensar em uma interface como uma classe que só pode ter métodos abstratos e nada mais.

Portanto, uma interface pode apenas "declarar" e não definir o comportamento que você deseja que a classe tenha.

Uma classe abstrata permite que você declare (usando métodos abstratos) e defina (usando implementações completas de método) o comportamento que deseja que a classe tenha.

E uma classe regular apenas permite definir, não declarar, o comportamento / ações que você deseja que a classe tenha.

Uma última coisa,

Em Java, você pode implementar várias interfaces, mas só pode estender uma (Classe ou Classe Abstrata) ...

Isso significa que a herança do comportamento definido é restrita a permitir apenas um por classe ... ou seja, se você quiser uma classe que encapsule o comportamento das classes A, B e C, precisará fazer o seguinte: A classe A estende B, a classe C estende A .. é meio que uma maneira de ter herança múltipla ...

Interfaces, por outro lado, você poderia simplesmente fazer: a interface C implementa A, B

Portanto, Java efetivamente suporta herança múltipla apenas em "comportamento declarado", ou seja, interfaces, e apenas herança única com comportamento definido.

Espero que isso faça sentido.

A comparação entre interface versus classe abstrata está errada. Em vez disso, deve haver outras duas comparações: 1) interface vs. classe e 2) resumo versus classe final .

Interface vs Classe

Interface é um contrato entre dois objetos. Por exemplo, eu sou um Carteiro e você é um Pacote para entregar. Espero que você saiba seu endereço de entrega. Quando alguém me entrega um pacote, ele precisa saber seu endereço de entrega:

interface Package {
  String address();
}

Classe é um grupo de objetos que obedecem ao contrato. Por exemplo, sou uma caixa do grupo "Caixa" e obedeço ao contrato exigido pelo Carteiro. Ao mesmo tempo, obedeço a outros contratos:

class Box implements Package, Property {
  @Override
  String address() {
    return "5th Street, New York, NY";
  }
  @Override
  Human owner() {
    // this method is part of another contract
  }
}

Resumo vs Final

A classe abstrata é um grupo de objetos incompletos. Eles não podem ser usados, porque perdem algumas partes. Por exemplo, sou uma caixa abstrata com reconhecimento de GPS - sei como verificar minha posição no mapa:

abstract class GpsBox implements Package {
  @Override
  public abstract String address();
  protected Coordinates whereAmI() {
    // connect to GPS and return my current position
  }
}

Essa classe, se herdada / estendida por outra classe, pode ser muito útil. Mas por si só - é inútil, pois não pode ter objetos. As aulas abstratas podem criar elementos das aulas finais.

A classe final é um grupo de objetos completos, que podem ser usados, mas não podem ser modificados. Eles sabem exatamente como trabalhar e o que fazer. Por exemplo, eu sou uma caixa que sempre vai para o endereço especificado durante sua construção:

final class DirectBox implements Package {
  private final String to;
  public DirectBox(String addr) {
    this.to = addr;
  }
  @Override
  public String address() {
    return this.to;
  }
}

Na maioria das linguagens, como Java ou C ++, é possível ter apenas uma classe , nem abstrata nem final. Essa classe pode ser herdada e instanciada. Eu não acho que isso esteja estritamente alinhado com o paradigma orientado a objetos.

Mais uma vez, comparar interfaces com classes abstratas não está correto.

Em resumo, as diferenças são as seguintes:

Diferenças sintáticas entre interface e classe abstrata :

1. Métodos e membros de uma classe abstrata podem ter qualquer visibilidade. Todos os métodos de uma interface devem ser públicos . // Não é mais verdadeiro no Java 9
2. Uma classe filho concreta de uma Classe Abstrata deve definir todos os métodos abstratos. Uma classe filho Abstract pode ter métodos abstratos. Uma interface que estende outra interface não precisa fornecer implementação padrão para métodos herdados da interface pai.
3. Uma classe filho pode estender apenas uma única classe. Uma interface pode estender várias interfaces. Uma classe pode implementar várias interfaces.
4. Uma classe filha pode definir métodos abstratos com a mesma visibilidade ou menos restritiva, enquanto a classe que implementa uma interface deve definir todos os métodos da interface como públicos.
5. As classes abstratas podem ter construtores, mas não interfaces .
6. As interfaces do Java 9 têm métodos estáticos privados.

Em Interfaces agora:

public static- suportado
public abstract- suportado
public default- suportado
private static- suportado
private abstract- erro de
private defaultcompilação
private- erro de compilação - suportado

A única diferença é que um pode participar de herança múltipla e outro não.

A definição de uma interface mudou ao longo do tempo. Você acha que uma interface possui apenas declarações de método e são apenas contratos? E as variáveis ​​finais estáticas e as definições padrão após o Java 8?

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

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

Consulte Por que o Java permite variáveis ​​finais estáticas nas interfaces quando se destinam apenas a contratos? .

Interface: Vire (vire à esquerda, vire à direita).

Classe abstrata: Roda.

Classe: o volante, deriva do volante, expõe o giro da interface

Um é para categorizar o comportamento que pode ser oferecido em uma gama diversificada de coisas, o outro é para modelar uma ontologia de coisas.

Se você possui alguns métodos comuns que podem ser usados ​​por várias classes, escolha classes abstratas. Caso contrário, se você quiser que as classes sigam algum plano definitivo, vá para interfaces.

Os exemplos a seguir demonstram isso.

Classe abstrata em Java:

abstract class animals
{
    // They all love to eat. So let's implement them for everybody
    void eat()
    {
        System.out.println("Eating...");
    }
    // The make different sounds. They will provide their own implementation.
    abstract void sound();
}

class dog extends animals
{
    void sound()
    {
        System.out.println("Woof Woof");
    }
}

class cat extends animals
{
    void sound()
    {
        System.out.println("Meoww");
    }
}

A seguir está uma implementação da interface em Java:

interface Shape
{
    void display();
    double area();
}

class Rectangle implements Shape 
{
    int length, width;
    Rectangle(int length, int width)
    {
        this.length = length;
        this.width = width;
    }
    @Override
    public void display() 
    {
        System.out.println("****\n* *\n* *\n****"); 
    }
    @Override
    public double area() 
    {
        return (double)(length*width);
    }
} 

class Circle implements Shape 
{
    double pi = 3.14;
    int radius;
    Circle(int radius)
    {
        this.radius = radius;
    }
    @Override
    public void display() 
    {
        System.out.println("O"); // :P
    }
    @Override
    public double area() 
    { 
        return (double)((pi*radius*radius)/2);
    }
}

Alguns pontos-chave importantes em poucas palavras:

1. As variáveis ​​declaradas na interface Java são, por padrão, finais. As classes abstratas podem ter variáveis ​​não finais.

2. As variáveis ​​declaradas na interface Java são, por padrão, estáticas. Classes abstratas podem ter variáveis ​​não estáticas.

3. Membros de uma interface Java são públicos por padrão. Uma classe abstrata Java pode ter os sabores usuais dos membros da classe, como privado, protegido, etc.

Muitos desenvolvedores juniores cometem o erro de pensar em interfaces, classes abstratas e concretas como pequenas variações da mesma coisa e escolhem uma delas puramente por motivos técnicos: Preciso de herança múltipla? Preciso de algum lugar para colocar métodos comuns? Preciso me preocupar com algo que não seja apenas uma aula concreta? Isso está errado, e oculto nessas perguntas está o principal problema: "eu" . Quando você escreve um código para si mesmo, raramente pensa em outros desenvolvedores atuais ou futuros trabalhando no seu código ou com ele.

As interfaces e as classes abstratas, embora aparentemente semelhantes do ponto de vista técnico, têm significados e propósitos completamente diferentes.

Sumário

1. Uma interface define um contrato que alguma implementação cumprirá para você .

2. Uma classe abstrata fornece um comportamento padrão que sua implementação pode reutilizar.

Resumo alternativo

1. Uma interface é para definir APIs públicas
2. Uma classe abstrata é para uso interno e para definir SPIs

Sobre a importância de ocultar detalhes de implementação

Uma classe concreta faz o trabalho real, de uma maneira muito específica. Por exemplo, um ArrayListusa uma área contígua da memória para armazenar uma lista de objetos de maneira compacta, que oferece acesso aleatório rápido, iteração e alterações no local, mas é terrível em inserções, exclusões e, ocasionalmente, inclusões; enquanto isso, umLinkedList usa nós com vínculo duplo para armazenar uma lista de objetos, que oferecem iteração rápida, alterações no local e inserção / exclusão / adição, mas são terríveis no acesso aleatório. Esses dois tipos de lista são otimizados para diferentes casos de uso, e importa muito como você os usará. Ao tentar extrair o desempenho de uma lista com a qual você está interagindo intensamente, e ao escolher o tipo de lista é sua, você deve escolher com cuidado qual deles está instanciando.

Por outro lado, os usuários de alto nível de uma lista não se importam com como ela é realmente implementada e devem ser isolados desses detalhes. Vamos imaginar que o Java não expôs a Listinterface, mas só tinha uma Listclasse concreta que é realmente o que LinkedListé agora. Todos os desenvolvedores Java teriam adaptado seu código para atender aos detalhes da implementação: evitar acesso aleatório, adicionar um cache para acelerar o acesso ou apenas reimplementar ArrayListpor conta própria, embora isso seja incompatível com todo o outro código que realmente funciona comList apenas. Isso seria terrível ... Mas agora imagine que os mestres Java realmente percebam que uma lista vinculada é terrível para a maioria dos casos de uso reais e decidiram mudar para uma lista de matrizes apenas paraListclasse disponível. Isso afetaria o desempenho de todos os programas Java do mundo e as pessoas não ficariam felizes com isso. E o principal culpado é que os detalhes da implementação estavam disponíveis, e os desenvolvedores assumiram que esses detalhes são um contrato permanente em que podem confiar. É por isso que é importante ocultar os detalhes da implementação e definir apenas um contrato abstrato. Esse é o objetivo de uma interface: defina que tipo de entrada um método aceita e que tipo de saída é esperado, sem expor todas as tripas que tentariam os programadores a ajustar seu código para ajustar os detalhes internos que podem mudar com qualquer atualização futura .

Uma classe abstrata está no meio entre interfaces e classes concretas. Ele deve ajudar as implementações a compartilhar código comum ou chato. Por exemplo, AbstractCollectionfornece implementações básicas com isEmptybase no tamanho é 0, containscomo iterar e comparar, addAllconforme repetido add, e assim por diante. Isso permite que as implementações se concentrem nas partes cruciais que diferem entre elas: como realmente armazenar e recuperar dados.

APIs versus SPIs

Interfaces são gateways de baixa coesão entre diferentes partes do código. Eles permitem que as bibliotecas existam e evoluam sem interromper todos os usuários da biblioteca quando algo muda internamente. Chama-se Interface de Programação de Aplicativos , não Classes de Programação de Aplicativos. Em uma escala menor, eles também permitem que vários desenvolvedores colaborem com sucesso em projetos de grande escala, separando diferentes módulos por meio de interfaces bem documentadas.

As classes abstratas são ajudantes de alta coesão a serem usadas na implementação de uma interface, assumindo algum nível de detalhes de implementação. Como alternativa, classes abstratas são usadas para definir SPIs, interfaces de provedor de serviços.

A diferença entre uma API e uma SPI é sutil, mas importante: para uma API, o foco está em quem a usa e, para uma SPI, está focada em quem a implementa .

É fácil adicionar métodos a uma API, todos os usuários existentes da API ainda serão compilados. É difícil adicionar métodos a um SPI, pois todo provedor de serviços (implementação concreta) precisará implementar os novos métodos. Se forem usadas interfaces para definir uma SPI, o provedor precisará liberar uma nova versão sempre que o contrato da SPI for alterado. Se classes abstratas forem usadas, novos métodos poderão ser definidos em termos de métodos abstratos existentes ou como throw not implemented exceptionstubs vazios , o que permitirá pelo menos que uma versão mais antiga de uma implementação de serviço ainda seja compilada e executada.

Uma observação sobre Java 8 e métodos padrão

Embora o Java 8 tenha introduzido métodos padrão para interfaces, o que torna a linha entre interfaces e classes abstratas ainda mais embaçada, isso não foi para que as implementações possam reutilizar código, mas para facilitar a alteração de interfaces que servem tanto como API quanto como SPI (ou são usados ​​incorretamente para definir SPIs em vez de classes abstratas).

Qual usar?

1. A coisa deve ser usada publicamente por outras partes do código ou por outro código externo? Inclua uma interface para ocultar os detalhes da implementação do contrato abstrato público, que é o comportamento geral da coisa.
2. É a coisa algo que é suposto ter várias implementações com um monte de código em comum? Faça uma interface e uma implementação abstrata e incompleta.
3. Alguma vez haverá apenas uma implementação e ninguém mais a usará? Apenas faça disso uma aula concreta.
   1. "ever" é muito tempo, você pode jogar pelo seguro e ainda adicionar uma interface em cima dele.

Um corolário: o contrário é geralmente feito de maneira errada: ao usar algo , sempre tente usar a classe / interface mais genérica que você realmente precisa. Em outras palavras, não declare suas variáveis ​​como ArrayList theList = new ArrayList(), a menos que você realmente tenha uma dependência muito forte de ser uma lista de matrizes e nenhum outro tipo de lista cortaria isso para você. Use em List theList = new ArrayListvez disso, ou mesmo Collection theCollection = new ArrayListse o fato de ser uma lista e não qualquer outro tipo de coleção não for realmente importante.

Não é realmente a resposta para a pergunta original, mas depois de ter a resposta para a diferença entre elas, você entrará no dilema quando usar cada um: Quando usar interfaces ou classes abstratas? Quando usar os dois?

Eu tenho conhecimento limitado de OOP, mas ver interfaces como um equivalente de adjetivo na gramática funcionou para mim até agora (corrija-me se esse método for falso!). Por exemplo, os nomes de interface são como atributos ou recursos que você pode atribuir a uma classe e uma classe pode ter muitos deles: ISerializable, ICountable, IList, ICacheable, IHappy, ...

A herança é usada para dois propósitos:

• Permitir que um objeto considere membros de dados do tipo pai e implementações de métodos como seus.

• Permitir que uma referência a objetos de um tipo seja usada pelo código que espera uma referência ao supertipo de objeto.

Em idiomas / estruturas que suportam herança múltipla generalizada, geralmente há pouca necessidade de classificar um tipo como sendo uma "interface" ou uma "classe abstrata". Linguagens e estruturas populares, no entanto, permitirão que um tipo considere os membros de dados de outro tipo ou implementações de método como seus, mesmo que permita que um tipo seja substituível por um número arbitrário de outros tipos.

As classes abstratas podem ter membros de dados e implementações de métodos, mas só podem ser herdadas por classes que não herdam de outras classes. As interfaces quase não impõem restrições aos tipos que as implementam, mas não podem incluir nenhum membro de dados ou implementação de método.

Há momentos em que é útil que os tipos substituam muitas coisas diferentes; outras vezes, é útil que os objetos considerem os membros de dados do tipo pai e as implementações de métodos como seus. Fazer uma distinção entre interfaces e classes abstratas permite que cada uma dessas habilidades seja usada nos casos em que é mais relevante.

Pontos chave:

• A classe abstrata pode ter propriedades, campos de dados, métodos (completos / incompletos).
• Se método ou Propriedades definem na palavra-chave abstrata que deve substituir na classe derivada. (Funciona como uma funcionalidade fortemente acoplada)
• Se definir uma palavra-chave abstrata para método ou propriedades na classe abstrata, você não poderá definir o corpo do método e obter / definir o valor das propriedades, que devem substituir a classe derivada.
• A classe abstrata não suporta herança múltipla.
• A classe abstrata contém construtores.
• Uma classe abstrata pode conter modificadores de acesso para os subs, funções e propriedades.
• Somente Membro Completo da classe abstrata pode ser Estático.
• Uma interface pode herdar apenas de outra interface e não pode herdar de uma classe abstrata, onde como uma classe abstrata pode herdar de outra classe abstrata ou outra interface.

Vantagem:

• É um tipo de contrato que força todas as subclasses a manter as mesmas hierarquias ou padrões.
• Se várias implementações são do mesmo tipo e usam comportamento ou status comum, é melhor usar a classe abstrata.
• Se adicionarmos um novo método a uma classe abstrata, temos a opção de fornecer implementação padrão e, portanto, todo o código existente poderá funcionar corretamente.
• Permite uma execução rápida do que a interface. (Interface Requer mais tempo para encontrar o método real nas classes correspondentes.)
• Pode ser usado para acoplamentos apertados e frouxos.

encontre detalhes aqui ... http://pradeepatkari.wordpress.com/2014/11/20/interface-and-abstract-class-in-c-oops/

A maneira mais curta de resumir é que um interfaceé:

1. Totalmente abstrato, além de defaulte staticmétodos; embora tenha definições (assinaturas de método + implementações) para defaulte staticmétodos, ele possui apenas declarações (assinaturas de método) para outros métodos.
2. Sujeito a regras mais flexíveis que as classes (uma classe pode implementar vários se interfaceum interfacepode herdar de vários interfaces). Todas as variáveis ​​são implicitamente constantes, especificadas como public static finalou não. Todos os membros são implicitamente public, especificados ou não.
3. Geralmente usado como garantia de que a classe de implementação terá os recursos especificados e / ou seja compatível com qualquer outra classe que implemente a mesma interface.

Enquanto isso, uma abstractclasse é:

1. De totalmente abstrato a totalmente implementado, com tendência a ter um ou mais abstract métodos. Pode conter declarações e definições, com as declarações marcadas como abstract.
2. Uma classe de pleno direito e sujeita às regras que governam outras classes (só podem herdar de uma classe), com a condição de que não possa ser instanciada (porque não há garantia de que seja totalmente implementada). Pode ter variáveis ​​de membro não constantes. Pode implementar o controle de acesso dos membros, restringindo os membros comoprotected , privateou pacote privado (não especificado).
3. Geralmente usado para fornecer o máximo de implementação possível de ser compartilhado por várias subclasses ou para fornecer o máximo de implementação que o programador é capaz de fornecer.

Ou, se quisermos resumir tudo em uma única frase: An interfaceé o que a classe de implementação possui , mas uma abstractclasse é o que a subclasse é .

Gostaria de acrescentar mais uma diferença que faz sentido. Por exemplo, você tem uma estrutura com milhares de linhas de código. Agora, se você deseja adicionar um novo recurso ao longo do código usando o método enhanUI (), é melhor adicionar esse método na classe abstrata e não na interface. Porque, se você adicionar esse método em uma interface, deverá implementá-lo em toda a classe implementada, mas não será o caso se você adicionar o método na classe abstrata.

Para dar uma resposta simples, mas clara, ajuda a definir o contexto: você usa os dois quando não deseja fornecer implementações completas.

A principal diferença, então, é que uma interface não possui nenhuma implementação (apenas métodos sem um corpo), enquanto as classes abstratas também podem ter membros e métodos com um corpo, ou seja, podem ser parcialmente implementadas.

Diferenças entre classe abstrata e interface em nome da implementação real.

Interface : é uma palavra-chave e é usada para definir o modelo ou a impressão azul de um objeto e força todas as subclasses a seguirem o mesmo protótipo. Na implementação, todas as subclasses são livres para implementar a funcionalidade conforme é requisito.

Alguns outros casos de uso em que devemos usar a interface.

A comunicação entre dois objetos externos (integração de terceiros em nosso aplicativo) feita através da Interface aqui Interface funciona como Contrato.

Classe abstrata: abstrata, é uma palavra-chave e, quando usamos essa palavra-chave antes de qualquer classe, torna-se abstrata. É usada principalmente quando precisamos definir o modelo, bem como algumas funcionalidades padrão de um objeto que é seguido por todos os subclasses e dessa maneira remove o código redundante e mais um caso de uso em que podemos usar a classe abstrata , como queremos que nenhuma outra classe instancie diretamente um objeto da classe, somente classes derivadas podem usar a funcionalidade.

Exemplo de Classe Abstrata:

 public abstract class DesireCar
  {

 //It is an abstract method that defines the prototype.
     public abstract void Color();

  // It is a default implementation of a Wheel method as all the desire cars have the same no. of wheels.   
 // and hence no need to define this in all the sub classes in this way it saves the code duplicasy     

  public void Wheel() {          

               Console.WriteLine("Car has four wheel");
                }
           }


    **Here is the sub classes:**

     public class DesireCar1 : DesireCar
        {
            public override void Color()
            {
                Console.WriteLine("This is a red color Desire car");
            }
        }

        public class DesireCar2 : DesireCar
        {
            public override void Color()
            {
                Console.WriteLine("This is a red white Desire car");
            }
        }

Exemplo de interface:

  public interface IShape
        {
          // Defines the prototype(template) 
            void Draw();
        }


  // All the sub classes follow the same template but implementation can be different.

    public class Circle : IShape
    {
        public void Draw()
        {
            Console.WriteLine("This is a Circle");
        }
    }

    public class Rectangle : IShape
    {
        public void Draw()
        {
            Console.WriteLine("This is a Rectangle");
        }
    }

Você pode encontrar uma clara diferença entre interface e classe abstrata.

Interface

• A interface contém apenas métodos abstratos.
• Força os usuários a implementar todos os métodos quando implementam a interface.
• Contém apenas variáveis ​​finais e estáticas.
• Declarar usando a palavra-chave da interface.
• Todos os métodos de uma interface devem ser definidos como públicos.
• Uma interface pode se estender ou uma classe pode implementar várias outras interfaces.

Classe abstrata

• A classe Abstract contém métodos abstratos e não abstratos.

• Não força os usuários a implementar todos os métodos quando herdados da classe abstrata.

• Contém todos os tipos de variáveis, incluindo primitivas e não primitivas

• Declarar usando palavra-chave abstrata.

• Métodos e membros de uma classe abstrata podem ser definidos com qualquer visibilidade.

• Uma classe filho só pode estender uma única classe (abstrata ou concreta).

Uma classe abstrata é uma classe cujo objeto não pode ser criado ou uma classe que não pode ser instanciada. Um método abstrato torna uma classe abstrata. Uma classe abstrata precisa ser herdada para substituir os métodos declarados na classe abstrata. Nenhuma restrição nos especificadores de acesso. Uma classe abstrata pode ter construtor e outros métodos concretos (métodos não-abstarct), mas a interface não pode ter.

Uma interface é um modelo / modelo de métodos (por exemplo, é fornecida uma casa em um papel (casa da interface) e diferentes arquitetos usarão suas idéias para construí-la (as classes de arquitetos que implementam a interface da casa). métodos abstratos, métodos padrão, métodos estáticos, variáveis ​​finais e classes aninhadas.Todos os membros serão finais ou públicos, não são permitidos especificadores de acesso protegido e privado.Não é permitida a criação de objetos. É necessário criar uma classe para usar o método interface de implementação e também para substituir o método abstrato declarado na interface.Uma interface é um bom exemplo de acoplamento flexível (polimorfismo dinâmico / ligação dinâmica) Uma interface implementa polimorfismo e abstração.Ele diz o que fazer, mas como fazer é definido pelo classe de implementação.Por exemplo:uma empresa de automóveis e deseja que alguns recursos sejam iguais para todo o carro que está fabricando, para que a empresa esteja criando um veículo de interface que terá esses recursos e diferentes classes de carro (como Maruti Suzkhi, Maruti 800) substituirá esses recursos (funções).

Por que fazer interface quando já temos classe abstrata? Java suporta apenas herança multinível e hierárquica, mas com a ajuda da interface, podemos implementar herança múltipla.

Em termos de praticidade (JAVA), a principal diferença entre classe abstrata e interface é que a classe abstrata pode conter o estado. Além do estado de retenção, também podemos realizar operações de descanso com a Interface.

Em uma interface, todos os métodos devem ser apenas definições, e nenhum deve ser implementado.

Mas em uma classe abstrata deve haver um método abstrato apenas com definição, mas outros métodos também podem estar na classe abstrata com implementação ...

Temos várias diferenças estruturais / sintáticas entre interface e classe abstrata. Mais algumas diferenças são

[1] Diferença baseada no cenário :

Classes abstratas são usadas em cenários quando queremos restringir o usuário a criar objetos da classe pai E acreditamos que haverá mais métodos abstratos que serão adicionados no futuro.

A interface deve ser usada quando tivermos certeza de que não existe mais um método abstrato a ser fornecido. Então, apenas uma interface é publicada.

[2] Diferença conceitual :

"Precisamos fornecer métodos mais abstratos no futuro" se SIM a tornar abstrata e se NÃO a interface.

(Mais apropriado e válido até java 1.7)

geralmente classe abstrata usada para o núcleo de algo, mas interface usada para anexar periféricos.

quando você deseja criar um tipo de base para veículo, deve usar a classe abstrata, mas se deseja adicionar alguma funcionalidade ou propriedade que não faz parte do conceito básico de veículo, deve usar a interface, por exemplo, deseja adicionar a função "ToJSON ()" .

A interface possui uma ampla gama de abstração, em vez de classe abstrata. você pode ver isso passando argumentos. veja este exemplo:

se você usar veículo como argumento, poderá usar um de seu tipo derivado (ônibus ou carro - mesma categoria - apenas categoria veículo). mas quando você usa a interface IMoveable como argumento, você tem mais opções.