Skip to main content

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.

Labels:

Comments

Post a Comment

Popular posts from this blog

C# : How can we access private method outside class

Introduction In object-oriented programming, encapsulation is a fundamental principle that restricts direct access to the internal implementation details of a class. Private methods, being part of this internal implementation, are designed to be accessible only within the confines of the class they belong to. However, there might be scenarios where you need to access a private method from outside the class. In this blog post, we'll explore several techniques to achieve this in C#. 1. Reflection: A Powerful Yet Delicate Approach Reflection is a mechanism in C# that allows inspecting and interacting with metadata about types, fields, properties, and methods. While it provides a way to access private methods, it should be used cautiously due to its potential impact on maintainability and performance. using System ; using System . Reflection ; public class MyClass { private void PrivateMethod ( ) { Console . WriteLine ( "This is a private method."
Post a Comment
Read more

C# : Understanding Types of Classes

In C#, classes serve as the building blocks of object-oriented programming, providing a blueprint for creating objects. Understanding the types of classes and their applications is crucial for designing robust and maintainable software. In this blog, we’ll delve into various types of classes in C#, accompanied by real-world scenarios and code snippets for a practical understanding. 1. Regular (Instance) Classes Definition: Regular classes are the most common type and are used to create instances or objects. They can contain fields, properties, methods, and other members. Example Scenario: A Person class representing individual persons with properties like Name and Age. public class Person { public string Name { get ; set ; } public int Age { get ; set ; } } 2. Static Classes Definition: A static class cannot be instantiated and can only contain static members (methods, properties, fields). It’s often used for utility functions. Example Scenario: A MathUtility cla
Post a Comment
Read more

C# : 12.0 : Primary constructor

Introduction In C# 12.0, the introduction of the "Primary Constructor" simplifies the constructor declaration process. Before delving into this concept, let's revisit constructors. A constructor is a special method in a class with the same name as the class itself. It's possible to have multiple constructors through a technique called constructor overloading.  By default, if no constructors are explicitly defined, the C# compiler generates a default constructor for each class. Now, in C# 12.0, the term "Primary Constructor" refers to a more streamlined way of declaring constructors. This feature enhances the clarity and conciseness of constructor declarations in C# code. Lets see an simple example code, which will be known to everyone. public class Version { private int _value ; private string _name ; public Version ( int value , string name ) { _name = name ; _value = value ; } public string Ve
Post a Comment
Read more