Difference between abstract class and Interface

Theoretically there are basically 5 differences between Abstract Class and Interface which are listed as below :-

1. A class can implement any number of interfaces but a subclass can at most use only one abstract class.means Multiple inheritance is not possible in case of abstract class but in case of interface Multiple Inheritance is possible with interface.
2. An abstract class can have non-abstract Methods(concrete methods) while in case of Interface all the methods has to be abstract.
3. An Interface can contain property definitions. but in case of abstract class, it can implement a property. 
4. An Interface can be inherited from by structures. but in case of  abstract class, it cannot be inherited from by structures.
5. An abstract class can declare or use any variables while an interface is not allowed to do so.
   
   So following Code will not compile :-
   
   
   
   interface TestInterface
   {
       int x = 4;  // Filed Declaration in Interface
       void getMethod();
    
       string getName();
   }
    
   abstract class TestAbstractClass
   {
       int i = 4;
       int k = 3;
       public abstract void getClassName();
   }It will generate a compile time error as :-
   
   Error    1    Interfaces cannot contain fields .
   
   So we need to omit Field Declaration in order to compile the code properly.
   
   interface TestInterface{    void getMethod();    string getName();} 
   abstract class TestAbstractClass
   {
       int i = 4;
       int k = 3;
       public abstract void getClassName();
   }Above code compiles properly as no field declaration is there in Interface.
6. An abstract class can have constructor declaration while an interface can not do so.
   
   So following code will not compile :-
   interface TestInterface
   {
       // Constructor Declaration
       public TestInterface()
       {
       }
       void getMethod();
       string getName();
   }
    
   abstract class TestAbstractClass
   {
       public TestAbstractClass()
       {
       }
       int i = 4;
       int k = 3;
       public abstract void getClassName();
   }
   Above code will generate a compile time error as :-
   
   Error    1    Interfaces cannot contain constructors  So we need to omit constructor declaration from interface in order to compile  our code .
   
   Following code compile s perfectly :-
   interface TestInterface
   {
       void getMethod();
       string getName();
   }
    
   abstract class TestAbstractClass
   {
       public TestAbstractClass()
       {
       }
       int i = 4;
       int k = 3;
       public abstract void getClassName();
   }
7. An abstract Class is allowed to have all access modifiers for all of its member declaration while in interface  we can not declare any access modifier(including public) as all the members of interface are implicitly public. 
   
   Note here I am talking about the access specifiers of the member of interface and not about the interface.
   
   Following code will explain it better :-
   
   It is perfectly legal to give provide access specifier as  Public (Remember only public is allowed)
   public interface TestInterface
   {
       void getMethod();
       string getName();
   }
   Above code compiles perfectly.
   
   It is not allowed to give any access specifier to the members of the Interface.
   interface TestInterface
   {
       public void getMethod();
       public string getName();
   }Above code will generate a compile time error as :-
   
   Error    1    The modifier 'public' is not valid for this item.
   
   But the best way of declaring Interface will be to avoid access specifier on interface as well as members of interface.
   
   interface Test
   {
       void getMethod();
       string getName();
   }
   
   

   Interface	Abstract
   Declare With keyword “Interface”	Declare with keyword “Abstract”
   A class may inherit several interfaces.	A class may inherit only one abstract class.
   An interface cannot provide any code, just the signature.	An abstract class can provide complete, default code and/or just the details that have to be overridden.
   No fields can be defined in interfaces	An abstract class can have fields and constrants defined
   An interface cannot have access modifiers for the subs, functions, properties etc everything is assumed as public	An abstract class can contain access modifiers for the subs, functions, properties
   It can come in inheritance chain	In that this is not come in inheritance chain
   Slower	Faster
   It will not contain constructor	It will may or may not constructor
   It will only contain final variable	It will contain Final and instance variable