What is the purpose of the abstract keyword in C ? Mid Level

The abstract keyword in C# defines classes and members (methods, properties, events, indexers) that are incomplete and must be implemented by derived (non-abstract) classes. It enforces a specific structure and promotes code reusability through inheritance. Think of an abstract class as a blueprint with some parts left for others to fill in.

Related Concepts

• Abstract Classes
• Abstraction
• Inheritance
• Polymorphism
• Interfaces

Key Characteristics and Uses of the `abstract` Keyword

Abstract Classes Cannot Be Instantiated Directly

You cannot create an instance of an abstract class because it’s like having a blueprint for a car without an engine. It’s incomplete. The abstract class defines the common features, but specific implementations are left to the derived classes, such as a SportsCar or Truck, which would provide the concrete “engine” implementation.

Abstract Methods Have No Body

Abstract methods are like placeholders in the blueprint. They declare that a functionality must exist, but they don’t define how it works. This forces any class that inherits from the abstract class to provide its own specific implementation for the method. For example, an abstract CalculateArea method in a Shape class forces derived classes like Circle and Square to define how area is calculated for their specific shape.

Abstract Classes Can Contain Both Abstract and Non-Abstract Members

This allows for providing some default behavior in the base class while still enforcing certain methods to be implemented by derived classes. Think of a DatabaseConnection class. It might have concrete methods for opening and closing the connection (common behavior), but leave an abstract ExecuteQuery method for derived classes to handle different query types (specific behavior).

Abstract Classes Support Polymorphism

Polymorphism lets you treat objects of different classes that share a common abstract base class in a uniform way. For example, you can have an array of Shape objects, where each element is actually a Circle, Square, or Triangle. You can then call CalculateArea on each element, and the correct version for the specific shape will be executed, thanks to polymorphism.

The `abstract` Keyword Reinforces the Concept of Abstraction

Abstraction simplifies interaction with complex systems. Imagine a car – you don’t need to know how the engine works to drive it. Similarly, abstract classes hide the complex implementation details of derived classes, providing a cleaner, easier-to-use interface. This makes the code more maintainable and flexible because changes to the internal implementation of derived classes don’t affect the code that uses the abstract base class.

Practical Scenarios and Interview Insights

Choosing an Abstract Class Over an Interface

In interviews, be prepared to discuss scenarios where an abstract class is preferred. For example: “In a recent project, we needed to connect to different database systems (SQL Server, Oracle, etc.). We used an abstract class DatabaseConnection with common methods like Open() and Close() already implemented. This avoided code duplication. Then, we created derived classes for each specific database type, overriding an abstract ExecuteQuery() method to handle the specific syntax of each database. An interface wouldn’t have allowed us to provide the common Open() and Close() implementations.”

Contribution to the “Is-A” Relationship in Inheritance

Abstract classes define a hierarchical relationship between classes. For example, in a vehicle simulation project, we had an abstract class Vehicle with properties like Color and Speed. We then had derived classes like Car, Truck, and Motorcycle. Each of these is a Vehicle, inheriting its properties and defining specific behavior like StartEngine(). The ‘is-a’ relationship is crucial for code organization and reusability.

Defining Common Behavior for Related Classes

In a graphics library we developed, we had an abstract class Shape with an abstract CalculateArea() method. Derived classes like Circle, Rectangle, and Triangle each provided their own implementation of CalculateArea(). This ensured that all shapes had a way to calculate their area, but the specific calculation differed based on the shape. This common behavior enforced by the abstract class simplified working with different shapes.

Enforcing a Common Contract

We used abstract classes to enforce a contract in our data access layer. We had an abstract class DataAccessObject defining methods like GetById(), Save(), and Delete(). Derived classes for specific entities (e.g., UserDao, ProductDao) implemented these methods. This ensured that all data access objects followed the same contract, simplifying the business logic layer’s interaction with the database.

Performance Implications

Using abstract classes doesn’t introduce any significant performance overhead. The method calls are resolved at compile time through polymorphism, so there’s no runtime penalty for using abstraction.

Code Sample: Demonstrating the `abstract` Keyword in C#

// Example of an abstract class
public abstract class Vehicle
{
    // Abstract method (no body) - must be implemented by derived classes
    public abstract void StartEngine();

    // Non-abstract method (with body) - can be used as-is or overridden
    public void StopEngine()
    {
        Console.WriteLine("Engine stopped.");
    }

    // Abstract property
    public abstract string Model { get; set; }
}

// Derived class implementing the abstract class
public class Car : Vehicle
{
    private string _model;

    // Implementation of the abstract method
    public override void StartEngine()
    {
        Console.WriteLine("Car engine started.");
    }

    // Implementation of the abstract property
    public override string Model
    {
        get { return _model; }
        set { _model = value; }
    }
}

// Another derived class
public class Motorcycle : Vehicle
{
    private string _model;

    // Implementation of the abstract method
    public override void StartEngine()
    {
        Console.WriteLine("Motorcycle engine started.");
    }

    // Implementation of the abstract property
     public override string Model
    {
        get { return _model; }
        set { _model = value; }
    }
}

// Usage
// Vehicle myVehicle = new Vehicle(); // Error: Cannot create an instance of the abstract type or interface 'Vehicle'

Vehicle car = new Car();
car.Model = "Sedan";
car.StartEngine(); // Output: Car engine started.
car.StopEngine();  // Output: Engine stopped.
Console.WriteLine($"Car Model: {car.Model}"); // Output: Car Model: Sedan

Vehicle motorcycle = new Motorcycle();
motorcycle.Model = "Cruiser";
motorcycle.StartEngine(); // Output: Motorcycle engine started.
motorcycle.StopEngine();  // Output: Engine stopped.
Console.WriteLine($"Motorcycle Model: {motorcycle.Model}"); // Output: Motorcycle Model: Cruiser

// Demonstrating polymorphism
List vehicles = new List();
vehicles.Add(new Car { Model = "SUV" });
vehicles.Add(new Motorcycle { Model = "Sportbike" });

foreach (var v in vehicles)
{
    v.StartEngine(); // Calls the appropriate StartEngine based on the actual object type
}
/* Output:
Car engine started.
Motorcycle engine started.
*/