Classes abstratas

Bem-vindo à próxima lição! Nesta lição, você aprenderá sobre classes abstratas em C#, sua finalidade e como elas diferem das interfaces. Vamos começar!

O que é uma classe abstrata?

Uma classe abstrata é uma classe que não pode ser instanciada diretamente. Ela serve como modelo para outras classes e pode incluir métodos abstratos, que devem ser implementados pelas classes derivadas.

Ponto-chave: As classes abstratas podem incluir tanto métodos totalmente implementados quanto métodos apenas declarados (métodos abstratos).

Definindo uma classe abstrata

Para definir uma classe abstrata, use a palavra-chave abstract. Exemplo:

Dica: Use classes abstratas para fornecer uma base comum para classes relacionadas.

using System;

abstract class Animal {
    public abstract void Speak(); // Abstract method
    public void Sleep() { // Non-abstract method
        Console.WriteLine("The animal is sleeping.");
    }
}

Implementando uma classe abstrata

As classes derivadas devem implementar todos os métodos abstratos da classe abstrata. Exemplo:

Ponto-chave: Os métodos abstratos definem o comportamento que deve ser implementado pelas classes derivadas.

using System;

abstract class Animal {
    public abstract void Speak(); // Abstract method
    public void Sleep() {
        Console.WriteLine("The animal is sleeping.");
    }
}

class Dog : Animal {
    public override void Speak() {
        Console.WriteLine("The dog barks.");
    }
}

class Program {
    static void Main() {
        Dog myDog = new Dog();
        myDog.Speak(); // Outputs: The dog barks.
        myDog.Sleep(); // Outputs: The animal is sleeping.
    }
}

Classes abstratas versus interfaces

Tanto as classes abstratas quanto as interfaces são usadas para abstração, mas diferem em vários aspectos:

• As classes abstratas podem ter métodos implementados e abstratos, enquanto as interfaces só podem ter métodos abstratos (antes do C# 8.0).
• As classes abstratas podem incluir campos, construtores e modificadores de acesso para seus membros.
• Uma classe pode herdar de apenas uma classe abstrata, mas pode implementar várias interfaces.

Dica: Use classes abstratas para classes estreitamente relacionadas e interfaces para uma abstração mais ampla.

Quando usar classes abstratas

As classes abstratas são mais adequadas quando:

• Você deseja definir uma classe base comum com funcionalidade compartilhada.
• Você precisa incluir métodos não abstratos que forneçam uma implementação padrão.
• Você está trabalhando com classes relacionadas que compartilham uma hierarquia comum.

Exemplo: Uma classe abstrata “Shape” para as classes “Circle” e “Rectangle”.

Desafio prático

Crie uma classe abstrata Shape com um método abstrato CalculateArea(). Implemente esse método nas classes derivadas Rectangle e Circle. Exemplo:

using System;

abstract class Shape {
    public abstract double CalculateArea();
}

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

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

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

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

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

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

Melhores práticas para classes abstratas

Veja algumas práticas recomendadas:

• Use classes abstratas quando houver funcionalidade compartilhada que precise ser herdada.
• Mantenha a classe abstrata focada e evite adicionar membros desnecessários.
• Combine classes abstratas com interfaces quando apropriado.

Dica: As classes abstratas devem fornecer uma base sólida para as classes derivadas.

Muito bem!

Parabéns! Você aprendeu a usar classes abstratas para definir comportamentos compartilhados e impor consistência entre classes derivadas. Na próxima lição, vamos explorar membros e métodos estáticos em C#. Continue programando!