Class abstrata x Interface

Tanto as classes abstratas e quanto as interfaces podem definir métodos abstratos que precisam ser implementados pelas class que estende ou implementa, porém somente as classes abstratas podem possuir métodos concretos.

Apesar dessa diferença vamos notar que teremos a repostas mais conceitual do que relacionada com questões referente a linguagem.

Quando a abstração e um comportamento então creio que a melhor solução e utilizar uma interface, quando a abstração e mais conceitual, algo que precisa ser especializado e refinado creio que a melhor solução e construir uma class abstrata.

Por um momento vamos imaginar que precisamos criar uma árvore.

Vamos as características de uma árvore, toda árvore possui algumas características listada abaixo.

Arvore:

  • Folha.
  • Galho.
  • Tronco.
  • Fruto.

Note que a característica fruto está em vermelho como não é novidade tem árvore que são frutíferas e arvores que não são.

Então podemos dizer que todas as árvores em um determinado ponto tem uma característica comum, porém existe características incomuns quando falamos de outros pontos, como no exemplo o fruto seria uma característica incomum.

Nesse exemplo poderíamos utilizar uma class abstrata, abaixo irei colocar alguns exemplos dessa implementação.

 public abstract class Arvore
 {
        public void Folha()
        {
            throw new NotImplementedException();
        }

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

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

        public abstract string Fruto();

 }
public class Abacateiro : Arvore
{
        public override string Fruto()
        {
            return "Abacate";
        }
}
 public class Goiabeira : Arvore
 {
        public override string Fruto()
        {
            return "Goiaba";
        }
 }

Testando nossa implementação:

    [TestClass]
    public class TesteArvoreAbstract
    {
        [TestMethod]
        public void deve_retornar_o_fruto_goiaba()
        {
            Arvore arvore =  new Goiabeira();
            Assert.AreEqual("Goiaba", arvore.Fruto());

        }
        [TestMethod]
        public void deve_retornar_o_fruto_abacate()
        {
            Arvore arvore = new Abacateiro();

            Assert.AreEqual("Abacate", arvore.Fruto());
        }
    }

Outra maneira interessante seria:

public interface IArvore
{
 ICaracteristicasComuns CaracteristicasComuns {get; }
 CaracteristicasIncomuns CaracteristicasIncomuns { get; }

}
    public interface ICaracteristicasComuns
    {
        void Folha();

        void Galho();

        void Tronco();
    }
public abstract class CaracteristicasIncomuns
{
        public abstract string Fruto();
}
 public class Goiabeira : IArvore
 {

     public ICaracteristicasComuns CaracteristicasComuns
     {
            get { return new GoiabeiraPadrao(); }
     }

     public CaracteristicasIncomuns CaracteristicasIncomuns
     {
            get { return new GoiabeiraPersonalizada(); }
     }
 }
    public class GoiabeiraPadrao : ICaracteristicasComuns
    {

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

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

        public void Tronco()
        {
            throw new NotImplementedException();
        }
    }
 public class GoiabeiraPersonalizada : CaracteristicasIncomuns
 {
     public override string Fruto()
     {
            throw new NotImplementedException();
     }
  }

Conclusão: A melhor maneira de entendermos um conceito  e praticar e praticar, espero que todos tenham conseguido entender as diferenças entre class abstrata e interface, mais uma vez obrigado a todos, a dica de hoje e o livro Design Patterns com Java: Projeto orientado a objetos guiado por padrões.

LEAVE A COMMENT