Abstract Classes

Welcome to the next lesson! In this lesson, you’ll learn about abstract classes in C#, their purpose, and how they differ from interfaces. Let’s get started!

What is an Abstract Class?

An abstract class is a class that cannot be instantiated directly. It serves as a blueprint for other classes and may include abstract methods, which must be implemented by derived classes.

Key Point: Abstract classes can include both fully implemented methods and methods that are only declared (abstract methods).

Defining an Abstract Class

To define an abstract class, use the abstract keyword. Example:

Tip: Use abstract classes to provide a common base for related classes.

using System;

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

Implementing an Abstract Class

Derived classes must implement all abstract methods of the abstract class. Example:

Key Point: Abstract methods define behavior that must be implemented by derived classes.

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.
    }
}

Abstract Classes vs Interfaces

Both abstract classes and interfaces are used for abstraction, but they differ in several ways:

• Abstract classes can have both implemented and abstract methods, while interfaces can only have abstract methods (prior to C# 8.0).
• Abstract classes can include fields, constructors, and access modifiers for members.
• A class can inherit only one abstract class but can implement multiple interfaces.

Tip: Use abstract classes for closely related classes and interfaces for broader abstraction.

When to Use Abstract Classes

Abstract classes are best used when:

• You want to define a common base class with shared functionality.
• You need to include non-abstract methods that provide a default implementation.
• You are working with related classes that share a common hierarchy.

Example: A "Shape" abstract class for "Circle" and "Rectangle" classes.

Practice Challenge

Create an abstract class Shape with an abstract method CalculateArea(). Implement this method in derived classes Rectangle and Circle. Example:

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());
    }
}

Best Practices for Abstract Classes

Here are some best practices:

• Use abstract classes when you have shared functionality that needs to be inherited.
• Keep the abstract class focused and avoid adding unnecessary members.
• Combine abstract classes with interfaces when appropriate.

Tip: Abstract classes should provide a solid foundation for derived classes.

Great Job!

Congratulations! You’ve learned how to use abstract classes to define shared behavior and enforce consistency across derived classes. In the next lesson, we’ll explore static members and methods in C#. Let’s keep coding!