Introdução às interfaces

Bem-vindo à primeira lição de Conceitos avançados de programação! Nesta lição, você aprenderá sobre interfaces, sua finalidade e como usá-las para obter abstração e flexibilidade em seus programas C#. Vamos começar!

O que é uma interface?

Uma interface é um contrato que define um conjunto de métodos e propriedades que uma classe deve implementar. Ela própria não fornece uma implementação, mas garante que qualquer classe que a implemente siga um projeto específico.

Exemplo: Uma interface para um “Vehicle” poderia definir métodos como Start() e Stop(), que todos os veículos devem implementar.

Ponto-chave: As interfaces permitem criar código flexível e reutilizável ao separar o comportamento da implementação.

Definindo uma interface

Para definir uma interface em C#, use a palavra-chave interface. Exemplo:

Dica: Por convenção, os nomes de interfaces em C# começam com a letra I.

using System;

interface IVehicle {
    void Start();
    void Stop();
}

Implementando uma interface

Para implementar uma interface, uma classe deve definir todos os métodos e propriedades declarados na interface. Exemplo:

Ponto-chave: Uma classe pode implementar várias interfaces para oferecer vários comportamentos.

using System;

interface IVehicle {
    void Start();
    void Stop();
}

class Car : IVehicle {
    public void Start() {
        Console.WriteLine("Car is starting.");
    }

    public void Stop() {
        Console.WriteLine("Car is stopping.");
    }
}

class Program {
    static void Main() {
        IVehicle myCar = new Car();
        myCar.Start();
        myCar.Stop();
    }
}

Por que usar interfaces?

As interfaces oferecem várias vantagens:

• Abstração: Definir o comportamento sem especificar a implementação.
• Flexibilidade: Uma classe pode implementar várias interfaces, permitindo que desempenhe várias funções.
• Consistência: Impor uma estrutura comum entre classes relacionadas.

Dica: Use interfaces quando quiser definir um contrato compartilhado sem determinar como ele deve ser cumprido.

Combinando várias interfaces

Uma classe pode implementar várias interfaces para combinar diferentes conjuntos de comportamentos. Exemplo:

using System;

interface IVehicle {
    void Start();
    void Stop();
}

interface IRadio {
    void PlayMusic();
}

class Car : IVehicle, IRadio {
    public void Start() {
        Console.WriteLine("Car is starting.");
    }

    public void Stop() {
        Console.WriteLine("Car is stopping.");
    }

    public void PlayMusic() {
        Console.WriteLine("Playing music.");
    }
}

class Program {
    static void Main() {
        Car myCar = new Car();
        myCar.Start();
        myCar.PlayMusic();
        myCar.Stop();
    }
}

Desafio prático

Crie uma interface IShape com um método CalculateArea(). Implemente essa interface nas classes Rectangle e Circle. Exemplo:

using System;

interface IShape {
    double CalculateArea();
}

class Rectangle : IShape {
    public double Width { get; set; }
    public double Height { get; set; }

    public double CalculateArea() {
        return Width * Height;
    }
}

class Circle : IShape {
    public double Radius { get; set; }

    public double CalculateArea() {
        return Math.PI * Radius * Radius;
    }
}

class Program {
    static void Main() {
        IShape rectangle = new Rectangle { Width = 5, Height = 4 };
        IShape circle = new Circle { Radius = 3 };

        Console.WriteLine("Rectangle Area: " + rectangle.CalculateArea());
        Console.WriteLine("Circle Area: " + circle.CalculateArea());
    }
}

Melhores práticas para usar interfaces

Veja algumas práticas recomendadas:

• Use interfaces para definir contratos que as classes devem seguir.
• Prefira interfaces à herança para classes não relacionadas que compartilham um comportamento comum.
• Mantenha as interfaces focadas e evite incluir métodos ou propriedades desnecessários.

Dica: As interfaces devem descrever o que uma classe faz, não como ela faz isso.

Muito bem!

Parabéns! Você aprendeu os fundamentos das interfaces e como usá-las para obter abstração e flexibilidade em seus programas. Na próxima lição, vamos explorar as classes abstratas e aprender como elas diferem das interfaces. Continue programando!