Top 10 Questions and Answers on Abstract Class vs. Interface in C#

In object-oriented programming, both abstract classes and interfaces are used to achieve abstraction. They define contracts for what a class should do but differ significantly in how they define these contracts and how they can be used.

Top 10 Questions and Answers on Static vs Singleton in C#

1. What is an abstract class in C#?

An abstract class is a class that cannot be instantiated and can include abstract methods (methods without implementation) as well as concrete methods (methods with implementation). It is meant to be inherited by other classes.

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

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

// Usage
Animal myDog = new Dog();
myDog.MakeSound(); // Output: Bark
myDog.Sleep(); // Output: Sleeping

2. What is an interface in C#?

An interface defines a contract that implementing classes must adhere to. Interfaces can only contain method declarations, properties, events, and indexers but cannot include any implementation.

public interface IAnimal
{
    void MakeSound();
    void Sleep();
}

public class Cat : IAnimal
{
    public void MakeSound()
    {
        Console.WriteLine("Meow");
    }

    public void Sleep()
    {
        Console.WriteLine("Sleeping");
    }
}

// Usage
IAnimal myCat = new Cat();
myCat.MakeSound(); // Output: Meow
myCat.Sleep(); // Output: Sleeping

3. How do abstract classes and interfaces differ in terms of implementation?

• Abstract Class: Can include both abstract methods (without implementation) and concrete methods (with implementation).
• Interface: Can only include method declarations (without implementation).

4. When should you use an abstract class over an interface?

Use an abstract class when you need to share code among several closely related classes. Abstract classes are useful for defining a base class with some default behavior and for creating a common interface for a group of related classes.

5. When should you use an interface over an abstract class?

Use an interface when you need to define a contract that can be implemented by any class, regardless of where they are in the class hierarchy. Interfaces are ideal for defining capabilities that can be shared across unrelated classes.

6. Can a class inherit from multiple abstract classes?

No, a class in C# cannot inherit from multiple abstract classes. C# only supports single inheritance for classes.

7. Can a class implement multiple interfaces?

Yes, a class in C# can implement multiple interfaces. This allows a class to adhere to multiple contracts and provide various capabilities.

public interface IFlyable
{
    void Fly();
}

public interface ISwimmable
{
    void Swim();
}

public class Duck : IFlyable, ISwimmable
{
    public void Fly()
    {
        Console.WriteLine("Flying");
    }

    public void Swim()
    {
        Console.WriteLine("Swimming");
    }
}

// Usage
Duck duck = new Duck();
duck.Fly(); // Output: Flying
duck.Swim(); // Output: Swimming

8. Can interfaces have fields or constructors?

No, interfaces cannot have fields or constructors. They can only have method, property, event, and indexer declarations.

9. How can you achieve default behavior in an interface?

Since C# 8.0, interfaces can include default implementations for members. This allows interfaces to provide a base implementation while still allowing implementing classes to override it.

public interface IAnimal
{
    void MakeSound();
    
    void Sleep()
    {
        Console.WriteLine("Sleeping");
    }
}

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

// Usage
IAnimal myDog = new Dog();
myDog.MakeSound(); // Output: Bark
myDog.Sleep(); // Output: Sleeping

10. Can abstract classes and interfaces coexist?

Yes, abstract classes and interfaces can coexist. A class can inherit from an abstract class and implement one or more interfaces, combining the benefits of both.

public abstract class Animal
{
    public abstract void Eat();
}

public interface IFlyable
{
    void Fly();
}

public class Bird : Animal, IFlyable
{
    public override void Eat()
    {
        Console.WriteLine("Eating");
    }

    public void Fly()
    {
        Console.WriteLine("Flying");
    }
}

// Usage
Bird bird = new Bird();
bird.Eat(); // Output: Eating
bird.Fly(); // Output: Flying

Conclusion

Abstract classes and interfaces are both essential tools in object-oriented programming for achieving abstraction and defining contracts. Abstract classes are best used when creating a base class with some shared code and functionality, while interfaces are ideal for defining capabilities that can be implemented by any class. Understanding their differences and appropriate use cases is key to designing robust and flexible software.