Topic 6924 min readStructured Tutorial

Understanding Abstract Classes in C# Inheritance

Quick Answer

In C#, abstract classes provide a way to define base classes that cannot be instantiated directly but can contain abstract methods that derived classes must implement. They enable a common interface and shared code for related classes, facilitating polymorphism and code reuse in inheritance hierarchies.

Learning Objectives

Explain the purpose of Abstract Classes in a practical learning context.
Identify the main ideas, terms, and decisions involved in Abstract Classes.
Apply Abstract Classes in a simple real-world scenario or practice task.

Introduction

Inheritance is a core concept in object-oriented programming that allows a class to inherit members from another class.

Abstract classes in C# provide a way to define a base class with incomplete implementation, requiring derived classes to complete it.

This tutorial explains what abstract classes are, how to use them, and why they are useful in designing flexible and maintainable code.

Abstract classes define a contract and common behavior for derived classes.

What Are Abstract Classes?

An abstract class in C# is a class that cannot be instantiated directly. It serves as a blueprint for other classes.

It can contain abstract methods without implementation, which derived classes must override.

Abstract classes can also have implemented methods and fields to share common functionality.

Cannot create instances of an abstract class.
Can contain abstract and non-abstract members.
Derived classes must implement all abstract methods.

Declaring and Using Abstract Classes

To declare an abstract class, use the 'abstract' keyword before the class name.

Abstract methods are declared without a body and must be overridden in derived classes.

Derived classes inherit from the abstract class and provide implementations for abstract methods.

Use 'abstract' keyword for classes and methods.
Derived classes override abstract methods using 'override' keyword.
Abstract classes can have constructors, fields, properties, and implemented methods.

Example of an Abstract Class

Here is a simple example demonstrating an abstract class and its derived class.

Benefits of Using Abstract Classes

Abstract classes help enforce a common interface and shared behavior among related classes.

They promote code reuse by allowing shared code in the base class.

They enable polymorphism, allowing code to work with base class references while executing derived class implementations.

Enforce implementation of essential methods in derived classes.
Reduce code duplication by sharing common code.
Support polymorphic behavior in object-oriented design.

Abstract Classes vs Interfaces

Both abstract classes and interfaces define contracts for derived classes, but they have key differences.

Abstract classes can contain implementation and state, while interfaces only declare method signatures.

A class can inherit only one abstract class but can implement multiple interfaces.

Abstract classes can have fields and implemented methods.
Interfaces cannot contain fields and only declare methods (prior to C# 8.0).
Use abstract classes for shared code; use interfaces for multiple inheritance of behavior.

Comparison: Abstract Classes vs Interfaces
Feature	Abstract Class	Interface
Can contain implementation	Yes	No (except default interface methods in C# 8.0+)
Can have fields	Yes	No
Multiple inheritance	No	Yes
Use case

Practical Example

This example defines an abstract class 'Animal' with an abstract method 'MakeSound' and a concrete method 'Sleep'. The 'Dog' class inherits from 'Animal' and implements 'MakeSound'.

Examples

Abstract Class Example in C#

abstract class Animal {
    public abstract void MakeSound();
    public void Sleep() {
        Console.WriteLine("Sleeping...");
    }
}

class Dog : Animal {
    public override void MakeSound() {
        Console.WriteLine("Bark");
    }
}

class Program {
    static void Main() {
        Dog dog = new Dog();
        dog.MakeSound();  // Output: Bark
        dog.Sleep();      // Output: Sleeping...
    }
}

This example defines an abstract class 'Animal' with an abstract method 'MakeSound' and a concrete method 'Sleep'. The 'Dog' class inherits from 'Animal' and implements 'MakeSound'.

Best Practices

Use abstract classes when you want to share code among closely related classes.
Declare methods abstract only if you want derived classes to provide their own implementation.
Keep abstract classes focused on a single responsibility to maintain clarity.
Use abstract classes to define a common interface and shared behavior.

Common Mistakes

Trying to instantiate an abstract class directly.
Forgetting to override all abstract methods in derived classes.
Using abstract classes when interfaces would be more appropriate for multiple inheritance.
Adding too much unrelated functionality in an abstract class.

Hands-on Exercise

Create an Abstract Shape Class

Define an abstract class 'Shape' with an abstract method 'CalculateArea'. Create derived classes 'Circle' and 'Rectangle' that implement this method.

Expected output: Classes that calculate and return the area of the shape.

Hint: Use the 'abstract' keyword for the class and method. Override the method in derived classes.

Interview Questions

What is an abstract class in C#?

Interview

An abstract class is a class that cannot be instantiated and may contain abstract methods that derived classes must implement.

Can you instantiate an abstract class?

Interview

No, abstract classes cannot be instantiated directly.

What is the difference between an abstract class and an interface?

Interview

Abstract classes can have implemented methods and fields, while interfaces only declare method signatures. Also, a class can inherit one abstract class but implement multiple interfaces.