Interfaces

Nos capítulos anteriores, vimos as classes abstratas. Interfaces são muito parecidas com classes abstratas e compartilham o fato de que nenhuma instância delas pode ser criada. No entanto, as interfaces são ainda mais conceituais que as abstratas, já que nenhum corpo de método é permitido. Portanto, uma interface é como uma classe abstrata com nada além de métodos abstratos, e como não há métodos com código real, não há necessidade de campos. Propriedades são permitidas, assim como indexadores e eventos. Você pode considerar uma interface como um contrato - uma classe que implementa é necessária para implementar todos os métodos e propriedades. No entanto, a diferença mais importante é que, embora o C# não permita herança múltipla, onde as classes herdam mais do que uma única classe base, de fato permite a implementação de múltiplas interfaces!

Então, como tudo isso parece no código? Aqui está um exemplo bem completo. Dê uma olhada, talvez tente por conta própria e, em seguida, leia a explicação completa:

using System;
using System.Collections.Generic;

namespace Interfaces
{
    class Program
    {
        static void Main(string[] args)
        {
            List<Dog> dogs = new List<Dog>();
            dogs.Add(new Dog("Fido"));
            dogs.Add(new Dog("Bob"));
            dogs.Add(new Dog("Adam"));
            dogs.Sort();
            foreach(Dog dog in dogs)
                Console.WriteLine(dog.Describe());
            Console.ReadKey();
        }
    }

    interface IAnimal
    {
        string Describe();

        string Name
        {
            get;
            set;
        }
    }

    class Dog : IAnimal, IComparable
    {
        private string name;

        public Dog(string name)
        {
            this.Name = name;
        }

        public string Describe()
        {
            return "Hello, I'm a dog and my name is " + this.Name;
        }

        public int CompareTo(object obj)
        {
            if(obj is IAnimal)
                return this.Name.CompareTo((obj as IAnimal).Name);
            return 0;
        }

        public string Name
        {
            get { return name; }
            set { name = value; }
        }
    }
}

Vamos começar no meio, onde declaramos a interface. Como você pode ver, a única diferença de uma declaração de classe é a palavra-chave usada - interface em vez de classe. Além disso, o nome da interface é prefixado com um I for Interface - isso é simplesmente um padrão de codificação e não um requisito. Você pode chamar suas interfaces como quiser, mas como elas são tão usadas como classes que você pode ter dificuldade em dizer a diferença em algumas partes do seu código, o prefixo I faz muito sentido.

Em seguida, declaramos o método Describe e, em seguida, a propriedade Name, que tem uma palavra-chave get e set, tornando-a uma propriedade de leitura e gravável. Você também notará a falta de modificadores de acesso (públicos, privados, protegidos etc.), e isso é porque eles não são permitidos em uma interface - eles são todos públicos por padrão.

Em seguida é nossa classe Dog. Observe como é semelhante a herdar de outra classe, com os dois pontos entre o nome da classe e a classe/interface sendo subclassificados/implementados. No entanto, neste caso, duas interfaces são implementadas para a mesma classe, simplesmente separadas por uma vírgula. Você pode implementar quantas interfaces quiser, mas neste caso nós implementamos apenas duas - nossa própria interface IAnimal, e a interface IComparable do .NET, que é uma interface compartilhada para classes que podem ser classificadas. Agora, como você pode ver, implementamos o método e a propriedade da interface IAnimal, bem como um método CompareTo da interface IComparable.

Agora você pode estar pensando: se tivermos que fazer todo o nosso trabalho, implementando todos os métodos e propriedades, por que incomodar? E um bom exemplo de por que vale a pena, é dado no topo do nosso exemplo. Aqui, adicionamos vários objetos Dog a uma lista e depois classificamos a lista. E como a lista sabe como classificar os cães? Porque a nossa classe Dog tem um método CompareTo que pode dizer como comparar dois cães. E como a lista sabe que nosso objeto Dog pode fazer exatamente isso e qual método usar para comparar os cães? Porque nós dissemos isso, implementando uma interface que promete um método CompareTo! Essa é a verdadeira beleza das interfaces.