0This is probably one of the most commonly asked questions in any job interview for .Net. Before we look into the differences between the two lets find out the main features.
Abstract Class
By definition abstract class must have one abstract method meaning the class must have one method with abstract keyword attached with it along with its declaration. other members of the class are optional. We can have multiple non abstract methods or fields in an abstract class. We can use the below code to discuss the features of an abstract class
public abstract class car
{
public car() // abstract class constructor
{
Console.WriteLine("Abstract Class constructor");
}
public int noofWheels = 4; // non abstract fields
public int speed = 60; // non abstract fields
public int getSpeed() // non abstract method
{
return speed;
}
public abstract void features(); // abstract method
}
public class Audi : car
{
public Audi()// inherited class constructor
{
Console.WriteLine("Audi Class constructor");
}
private string carType = "Audi";
public override void features() // abstract method overriding
{
Console.WriteLine(carType);
}
}
class Program
{
static void Main(string[] args)
{
Audi a = new Audi();
a.features();
Console.ReadLine();
}
}
In the above example we can see the abstract class car with abstract method features, non abstract method getSpeed and fields noofWheels, speed. We have inherited the abstract car class in Audi class and over ridden the abstract method features(). In order to find the flow of execution we have written code blocks inside the constructor of both car and Audi class.
Interface
The interface has methods with only definition with out any declaration of methods, interface should not have any fields as well. In order to use we need to over ride all the methods while implementing the interface, meaning with in an interface all member methods are going to be abstract method. We can use the below code to discuss the features of an interface.
public interface Icar
{
void features();
string manufacturer();
}
public class Audi : Icar
{
public Audi()// inherited class constructor
{
Console.WriteLine("Audi Class constructor");
}
private string carType = "Audi A8";
private string carManufacturer = "Audi";
public override void features()
{
Console.WriteLine(carType);
}
public string manufacturer()
{
return carManufacturer;
}
class Program
{
static void Main(string[] args)
{
Audi a = new Audi();
a.features();
Console.WriteLine(a.manufacturer());
Console.ReadLine();
}
}
Output
Differences
- Abstract Class: Non abstract methods are allowed with in the class Interface: All member methods are abstract
- Abstract Class: Both methods are fields are allowed with in an abstract class Interface: Only methods are allowed
- Abstract Class: Can't inherit multiple abstract classes together with in a class, thus abstract class doesn't allow multiple inheritance Interface: Can inherit multiple interfaces with in a class, multiple inheritance in C# can only achieved through Interface
- Abstract Class: Can have constructor in an abstract class Interface: Interface doesn't have constructor as its interface provides only contract with the inherited class not actual memory allocation takes place in interface.
- Abstract Class: Abstract class might not provide multiple inheritance but it doesn't affect the basic architecture of a design Interface: Interface provides multiple inheritance but its a weak form of multiple inheritance so in case of complex projects it could affect the architecture of the application.
