QUAL VANTAGEM EM USAR INTERFACE E CLASSES ABSTRATA

KELLY 05/05/2015 12:48:50
#446377
Bom dia gente!

Estou aqui para tirar uma grande dúvida, a maioria dos projetos que eu mexo é com Windows Forms, estou estudando ASP.NET MVC e todos os projetos que trabalhei sempre foram realizando CRUD básico sem muita coisa complexa. Em todos os projetos eu nunca precisei criar uma Interface ou uma classe abstrata, já utilizei interfaces do próprio C# para trabalhar com listas genéricas, mas hoje surgiu uma grande dúvida. Quando vou precisar usar uma interface? E qual a vantagem de usar uma Classe abstrata?

Um grande abraço a todos!
MICHAELL 07/05/2015 16:53:27
#446462
classe abstrata basicamente é uma classe que nao pode ser instanciada no projeto.
só serve de base para outras classes a estenderem.

a classe que implementar uma interface, deverá seguir os métodos e propriedades definidos na interface.
TUNUSAT 07/05/2015 17:06:44
#446464
Kellyyyy!

Coloquei um Artigo aqui que fala exatamente disso...

======================================================
CLASSES ABSTRATAS, CLASSES SELADAS E INTERFACES C#
http://vbmania.com.br/index.php?modulo=detalhe&id=9336
======================================================

Por favor, veja!

[][ô]s,
Tunusat.
KELLY 19/05/2015 17:59:15
#446784
Oi meus amigos, desculpem por demorar a responder, está muita correria no trabalho. Então eu só uso classe abstrata se eu quiser? Quer dizer então que Interface e classes abstratas são usadas só para definir um padrão de código?
KERPLUNK 19/05/2015 23:32:18
#446796
Não necessariamente. Uma Interface, serve basicamente para padronizar métodos e propriedades mas não podem conter código de maneira nenhuma, apenas as assinaturas de propriedades e métodos. Em uma classe abstrata, pode conter código que por sua vez pode ser sobreposto. Veja o exemplo:

    public class execucao
    {
        public void executar()
        {
            Cliente cli = new Cliente();
            cli.Nome = [Ô]Joaozinho[Ô];
            cli.Insert();

            Fornecedor forn = new Fornecedor();
            forn.Nome = [Ô]Outro nome[Ô];
            forn.Update();
        }
    }
    public class Cliente : CRUD<Cliente>
    {
        public String Nome { get; set; }
        public String Endereco { get; set; }
        public DateTime DataNascimento { get; set; }
        public int Avaliacao { get; set; }
    }
    public class Fornecedor : CRUD<Fornecedor>
    {
        public String Nome { get; set; }
        public String Endereco { get; set; }
        public string CNPJ { get; set; }
        public string Contato { get; set; }
        public override Fornecedor Update()
        {
            //faz a gravação do fornecedor e retorna o objeto
            return new Fornecedor();
        }
    }
    public abstract class CRUD<T> where T : CRUD<T>, new()
    {
        public static T GetObj()
        {
            return new T();
        }
        public Guid Codigo { get; set; }
       public void Insert()
        {

        }
        public T Update()
        {
            return new T();
        }
        public void Delete()
        {

        }
    }


Observando o exemplo, vemos que temos duas entidades simples, Cliente e Fornecedor. Ambas herdam a classe abstrata CRUD e por consequência, também herdam todas as suas propriedades(nesse exemplo, a propriedade Codigo) e métodos(Insert, Update e Delete). A entidade Cliente, utiliza o método Insert que contiver na classe CRUD. Já na entidade Fornecedor, o método Update, foi sobrescrito e portanto, quando chamarmos esse método à partir de uma instância de Fornecedor(no caso, [Ô]forn[Ô]), o método update que será utilizado será o método que estiver na classe Fornecedor e não o método Update que está na classe abstrata CRUD. Basicamente esse é um dos melhores usos de uma classe abstrata. Para uma interface, nenhum código poderia ser usado na interface em si e a herança seria simplesmente das assinaturas de métodos e propriedades que cada classe que a herdar deve conter a implementação dos mesmos, como no exemplo:

   public class execucao
    {
        public void executar()
        {
            Cliente cli = new Cliente();
            cli.Nome = [Ô]Joaozinho[Ô];
            cli.Insert();

            Fornecedor forn = new Fornecedor();
            forn.Contato = [Ô]Outro nome[Ô];
            forn.Update();
        }
    }
    public class Cliente : ICliente<Cliente>
    {
        public Guid Codigo
        {
            get
            {
                throw new NotImplementedException();
            }
            set
            {
                throw new NotImplementedException();
            }
        }

        public string Nome
        {
            get
            {
                throw new NotImplementedException();
            }
            set
            {
                throw new NotImplementedException();
            }
        }

        public DateTime DataNascimento
        {
            get
            {
                throw new NotImplementedException();
            }
            set
            {
                throw new NotImplementedException();
            }
        }

        public void Insert()
        {
            throw new NotImplementedException();
        }

        public Cliente Update()
        {
            throw new NotImplementedException();
        }

        public Cliente Delete()
        {
            throw new NotImplementedException();
        }
    }
    public class Fornecedor : IFornecedor<Fornecedor>
    {

        public Guid Codigo
        {
            get
            {
                throw new NotImplementedException();
            }
            set
            {
                throw new NotImplementedException();
            }
        }

        public string CNPJ
        {
            get
            {
                throw new NotImplementedException();
            }
            set
            {
                throw new NotImplementedException();
            }
        }

        public string Contato
        {
            get
            {
                throw new NotImplementedException();
            }
            set
            {
                throw new NotImplementedException();
            }
        }

        public void Insert()
        {
            throw new NotImplementedException();
        }

        public Fornecedor Update()
        {
            throw new NotImplementedException();
        }

        public Fornecedor Delete()
        {
            throw new NotImplementedException();
        }
    }

    interface ICliente<T>
    {
        Guid Codigo { get; set; }
        String Nome { get; set; }
        DateTime DataNascimento { get; set; }
        void Insert();
        T Update();
        T Delete();
    }

    interface IFornecedor<T>
    {
        Guid Codigo { get; set; }
        String CNPJ { get; set; }
        String Contato { get; set; }
        void Insert();
        T Update();
        T Delete();
    }


Ambos os exemplos, tem uma funcionalidade similar, porém ao se utilizar Interface, toda a implementação de métodos e propriedades, deve ser feito na própria classe base, ou seja, a que herdou a Interface. é uma questão de opinião, mas isso, apesar de criar uma separação muito mais distinta entre códigos, acaba gerando código desnecessário, pois com o uso de classe abstrata, se podem fazer métodos básicos de busca, gravação e conversão e simplesmente herdar essa classe abstrata em qualquer entidade e todas as suas funcionalidades básicas estarão atendidas.

Estou montando vídeo aulas que, entre muitas outras coisas, faremos uso de uma classe abstrata que é capaz de suprir todos os métodos de gravação, busca e conversão de qualquer entidade à qual for aplicada, desde que a entidade seja construída de uma certa maneira. Mas creio que os exemplos que postei, já irão ajudar.
JABA 20/05/2015 16:55:34
#446822 Resposta escolhida
Na verdade, o principal motivo da INTERFACE é para usar a tal da HERANÇA MÚLTIPLA. Por exemplo:
Digamos que temos uma pessoa que é ao mesmo tempo Cliente e Vendedor. Para modelar isso, você poderia criar o seguinte:

Interface IVendedor
{
   int Comissao { get;  set; }
}

public Class Cliente : IVendedor
{
  string Nome { get;  set; }
  int Comissao { get;  set; } //propriedade da interface
}


Note que agora o cliente tem tanto características de Cliente como de Vendedor. Tudo vai depender de como o seu projeto precisa ser realmente modelado. Em muitos casos, não há a necessidade de usar a herança múltipla, bastando apenas usar a herança simples pra resolver o seu problema, já em outros casos, é altamente recomendado. Pra você ter uma ideia do que eu estou dizendo, veja como funciona as Listas genéricas do Visual Studio. Observe quantas interfaces eles criaram para implementá-las.
JABA 20/05/2015 17:10:32
#446824
As classes Abstratas você usa quando quer ter uma classe base para outras sem que exista a possibilidade de criarem uma instância diretamente por ela, mas por somente suas classes filhas, e que possivelmente possa ter um método abstrato dentro dela que seja comum a toda a hierarquia, forçando assim que os programadores criem outras classes para estendê-la. é como se fosse um contrato como que dizendo o seguinte: cumpra o que foi determinado, senão caia fora daqui.
Tópico encerrado , respostas não são mais permitidas
Voltar