In an interface class, all methods are
abstract without implementation whereas in an
abstract class, some methods we can define concrete. In interface, no accessibility modifiers are allowed. An
abstract class may have accessibility modifiers. Interface and
abstract class are basically a set of rules which you have to follow in case you are using them (inheriting them).
Abstract classes are closely related to interfaces. They are classes that cannot be instantiated, and are frequently either partially implemented, or not at all implemented. One key difference between
abstract classes and interfaces is that a class may implement an unlimited number of interfaces, but may inherit from only one
abstract (or any other kind of) class. A class that is derived from an
abstract class may still implement interfaces.
Abstract classes are useful when creating components because they allow you to specify an invariant level of functionality in some methods, but leave the implementation of other methods until a specific implementation of that class is needed. They also version well, because if additional functionality is needed in derived classes, it can be added to the base class without breaking code.
abstract class is the one that is not used to create objects. An
abstract class is designed to act as a base class (to be inherited by other classes).
Abstract class is a design concept in program development and provides a base upon which other classes are built.
Abstract classes are similar to interfaces. After declaring an
abstract class, it cannot be instantiated on its own, it must be inherited. Like interfaces,
abstract classes can specify members that must be implemented in inheriting classes. Unlike interfaces, a class can inherit only one
Abstractclasses can only specify members that should be implemented by all inheriting classes.
An interface looks like a class, but has no implementation. They’re great for putting together plug-n-play like architectures where components can be interchanged at will. Think Firefox Plug-in extension implementation. If you need to change your design, make it an interface. However, you may have
abstract classes that provide some default behavior.
Abstract classes are excellent candidates inside of application frameworks.
One additional key difference between interfaces and abstract classes (possibly the most important one) is that multiple interfaces can be implemented by a class, but only one
abstract class can be inherited by any single class.
Some background on this: C++ supports multiple inheritance, but C# does not. Multiple inheritance in C++ has always be controversial, because the resolution of multiple inherited implementations of the same method from different base classes is hard to control and anticipate. C# decided to avoid this problem by allowing a class to implement multiple interfaces, which do not contain method implementations, but restricting a class to have at most a single parent class. Although this can result in redundant implementations of the same method when different classes implement the same interface, it is still an excellent compromise.
Another difference between interfaces and
abstract classes is that an interface can be implemented by an
abstract class, but no class,
abstract or otherwise, can be inherited by an interface.
What is an Abstract class?
abstract class is a special kind of class that cannot be instantiated. So the question is why we need a class that cannot be instantiated? An
abstract class is only to be sub-classed (inherited from). In other words, it only allows other classes to inherit from it but cannot be instantiated. The advantage is that it enforces certain hierarchies for all the subclasses. In simple words, it is a kind of contract that forces all the subclasses to carry on the same hierarchies or standards.
What is an Interface?
An interface is not a class. It is an entity that is defined by the word Interface. An interface has no implementation; it only has the signature or in other words, just the definition of the methods without the body. As one of the similarities to
Abstract class, it is a contract that is used to define hierarchies for all subclasses or it defines specific set of methods and their arguments. The main difference between them is that a class can implement more than one interface but can only inherit from one
abstract class. Since C# doesn’t support multiple inheritance, interfaces are used to implement multiple inheritance.