Difference between abstraction and interface?

Hello Tai Khoan

First thing to note is that abstraction and interfaces are not specific to C#, it's a general concept of Oriented Object Programming.

The common points between abstract classes and interfaces is that both can't be instanciated directly.

The abstract class should be extended and the interface should be implemented by another class.

Then the main difference comes in the methods

If you have an abstract class, you can specifiy a body to some of your methods that will be common to all the daughter classes that will inherit from it.

In the interfaces you can't, you can just specifiy the declaration of the methods without any implementation.

Then for the real cases it depends on your need and on your design, I'll give you somes.

For example you have an implementation where you have to calculate the Age and the salary for the professors, then the age and the grades for the students. and you need to show the timeSheet for both but in a different form. (it's just a silly example to explain better)

Here it's better to use an abstract class Person where you define the common abstract and non abstract method that you can define in your daughet classes

public abstract class Person
{
public abstract void ShowTimeSheet();
public int CalculateAge(DateTime BirthDate)
{
return DateTime.Now.Year - BirthDate.Year;
}
}

public class Professor : Person
{
public double CalculateSalary()
{
//Do your calculation
return 5000;
}
public override void ShowTimeSheet()
{
//Show the specific time sheet of the professor
}
}

public class Student : Person
{
public double CalculateGrade()
{
//Do your calculation
return 100;
}
public override void ShowTimeSheet()
{
//Show the specific timeSheet of the Student
}
}

And for the example of the interface, you can use it when for example you have an application that interact with a hardware let's say a Camera, and every Camera has his own SDK (Software development Kit which is a library that generally comes with the hardware). Your application should be independant from the brand of the Camera, So here you create an interface with only the Method declaration, then you implement it by a class where you call the SDK of the hardware. The day when you will change the hardware you have only to change to class that implement the interface and not the whole code.

internal interface ICamera
{
public void InitializeCamera();
public void StartPreview();
public void CapturePicture();
}

Then for more advanced concepts, you can find the difference of usage in the Patterns. For example in the SOLID Principle, The "O" refers to the Open/Closed Principle https://en.wikipedia.org/wiki/Open%E2%80%93closed_principle, here it refers more to the abstraction and the "I" refers to the Interface Segregation https://en.wikipedia.org/wiki/Interface_segregation_principle which means that a class should implement several interfaces to avoid having useless methods in it.

I hope this helps you to have a better understanding.

4 Replies

Know the answer? Post it — somebody with the same question will find it here.

Jaydeep Patil4y ago
Check the following links that might help you

https://www.c-sharpcorner.com/article/when-to-use-abstract-class-and-interface-in-real-time-projects/
Amit Mohanty4y ago
Please check the below links

https://www.c-sharpcorner.com/article/when-to-use-abstract-class-and-interface-in-real-time-projects/
http://www.dotnetstudy.com/abstract-class-vs-interface-real-time-scenarios-to-decide-when-to-use-abstract-class-and-when-to-use-interface?id=27
Vishal Yelve4y ago
Please watch Shivprasad Koirala sir's video on Abstract vs Interface Url: https://youtu.be/0EnSPBVrbG0
Aymen Amri4y ago
Hello Tai Khoan

First thing to note is that abstraction and interfaces are not specific to C#, it's a general concept of Oriented Object Programming.

The common points between abstract classes and interfaces is that both can't be instanciated directly.
The abstract class should be extended and the interface should be implemented by another class.

Then the main difference comes in the methods
If you have an abstract class, you can specifiy a body to some of your methods that will be common to all the daughter classes that will inherit from it.
In the interfaces you can't, you can just specifiy the declaration of the methods without any implementation.

Then for the real cases it depends on your need and on your design, I'll give you somes.
For example you have an implementation where you have to calculate the Age and the salary for the professors, then the age and the grades for the students. and you need to show the timeSheet for both but in a different form. (it's just a silly example to explain better)
Here it's better to use an abstract class Person where you define the common abstract and non abstract method that you can define in your daughet classes
public abstract class Person
{
    public abstract void ShowTimeSheet();
    public int CalculateAge(DateTime BirthDate)
    {
        return DateTime.Now.Year - BirthDate.Year;
    }
}

public class Professor : Person
{
    public double CalculateSalary()
    {
        //Do your calculation
        return 5000;
    }

    public override void ShowTimeSheet()
    {
        //Show the specific time sheet of the professor
    }
}
public class Student : Person
{
    public double CalculateGrade()
    {
        //Do your calculation
        return 100;
    }

    public override void ShowTimeSheet()
    {
       //Show the specific timeSheet of the Student
    }
}
And for the example of the interface, you can use it when for example you have an application that interact with a hardware let's say a Camera, and every Camera has his own SDK (Software development Kit which is a library that generally comes with the hardware). Your application should be independant from the brand of the Camera, So here you create an interface with only the Method declaration, then you implement it by a class where you call the SDK of the hardware. The day when you will change the hardware you have only to change to class that implement the interface and not the whole code.
internal interface ICamera
    {
        public void InitializeCamera();
        public void StartPreview();
        public void CapturePicture();
    }
Then for more advanced concepts, you can find the difference of usage in the Patterns. For example in the SOLID Principle, The "O" refers to the Open/Closed Principle https://en.wikipedia.org/wiki/Open%E2%80%93closed_principle, here it refers more to the abstraction and the "I" refers to the Interface Segregation https://en.wikipedia.org/wiki/Interface_segregation_principle which means that a class should implement several interfaces to avoid having useless methods in it.

I hope this helps you to have a better understanding.