Explain the difference between an interface and an abstract class in objectoriented programming

Explain the difference between an interface and an abstract class in object oriented
programming.

Answer:

The specific answer to this depends on which language you’re developing with.

An interface declares a set of related methods, outside of any class.
An abstract class is an incomplete class definition that declares but does not define all of its methods.

An interface defines an application programming interface (API) that is independent of
any class hierarchy. In fact, interfaces can be used in non-OO programming models, such as
component based models like COM and CORBA. However, you’re focusing on the use of interfaces in an object-oriented context, where they are useful in their own right. Interfaces are the ultimate encapsulators, because they hide all the details of the classes that implement their methods from the user of the interface. They’re particularly important - almost necessary, in fact - in languages that only support single inheritance (classes can only inherit from one base class). A class that exposes its members via an interface is said to implement the interface.

Unlike an interface, an abstract class is a proper class: It can have data members and can be a subclass of other classes. Unlike a concrete (nonabstract) class, however, some of its behaviors are deliberately left to be defined by its own subclasses. Abstract classes cannot be instantiated because of this - only instances of concrete subclasses can be created.
An interface is almost identical to an abstract class with no data members and no method definitions.

In C++ this is exactly how you’d define an interface: by declaring a class with no data members and only pure virtual functions - something like this, for example:

class Interface {
public:
virtual void getState( int oState, int nState ) = 0;
};

A class could then “implement” the interface by deriving from it:

class MyClass : SomeOtherClass, Interface {
public:
void getState( int oState, int nState ){
if( nState > oState ){
..... // do stuff
}
}
.... // remainder of class
};

In Java, an interface is defined using the interface keyword:

public interface MyInterface
void getState( int oState, int nState );
}

The interface is then implemented by a class:

public class MyClass implements MyInterface {

public void getState( int oState, int nState ){
.... // do stuff
}
.... // remainder of class
}

A common pattern you’ll see with languages that support both interfaces and abstract classes is the provision of a default implementation of an interface via an abstract class. For example, the following

interface:

public interface XMLReader {
public XMLObject fromString( String str );
public XMLObject fromReader( Reader in );
}

might have this default implementation:

public abstract class XMLReaderImpl {
public XMLObject fromString( String str ){
fromString( new StringReader( str ) );
}
public abstract XMLObject fromReader( Reader in );
}

A programmer who wanted to implement XMLReader would then have the option of creating a class that
subclasses XMLReaderImpl (likely as a nested class) and only implement one method instead of two.