I have had recently two telephone interviews where I’ve been asked about the differences between an Interface and an Abstract class. I have explained every aspect of them I could think of, but it seems they are waiting for me to mention something specific, and I don’t know what it is.
From my experience I think the following is true. If I am missing a major point please let me know.
Every single Method declared in an Interface will have to be implemented in the subclass. Only Events, Delegates, Properties (C#) and Methods can exist in a Interface. A class can implement multiple Interfaces.
Only Abstract methods have to be implemented by the subclass. An Abstract class can have normal methods with implementations. Abstract class can also have class variables beside Events, Delegates, Properties and Methods. A class can only implement one abstract class only due non-existence of Multi-inheritance in C#.
- After all that, the interviewer came up with the question “What if you had an Abstract class with only abstract methods? How would that be different from an interface?” I didn’t know the answer but I think it’s the inheritance as mentioned above right?
- An another interviewer asked me what if you had a Public variable inside the interface, how would that be different than in Abstract Class? I insisted you can’t have a public variable inside an interface. I didn’t know what he wanted to hear but he wasn’t satisfied either.
While your question indicates it’s for “general OO”, it really seems to be focusing on .NET use of these terms.
In .NET (similar for Java):
- interfaces can have no state or implementation
- a class that implements an interface must provide an implementation of all the methods of that interface
- abstract classes may contain state (data members) and/or implementation (methods)
- abstract classes can be inherited without implementing the abstract methods (though such a derived class is abstract itself)
- interfaces may be multiple-inherited, abstract classes may not (this is probably the key concrete reason for interfaces to exist separately from abtract classes – they permit an implementation of multiple inheritance that removes many of the problems of general MI).
As general OO terms, the differences are not necessarily well-defined. For example, there are C++ programmers who may hold similar rigid definitions (interfaces are a strict subset of abstract classes that cannot contain implementation), while some may say that an abstract class with some default implementations is still an interface or that a non-abstract class can still define an interface.
Indeed, there is a C++ idiom called the Non-Virtual Interface (NVI) where the public methods are non-virtual methods that ‘thunk’ to private virtual methods: