Skip to main content

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.
Labels:

Comments

Post a Comment

Popular posts from this blog

Explain Polymorphism and Flavors of Polymorphism...

Polymorphism is the ability of different objects to react in an individual manner to the same message. This notion was imported from natural languages. For example, the verb "to close" means different things when applied to different objects. Closing a door, closing a bank account, or closing a program's window are all different actions; their exact meaning is determined by the object on which the action is performed. Most object-oriented languages implement polymorphism only in the form of virtual functions. But C++ has two more mechanisms of static (meaning: compile-time) polymorphism: Operator overloading. Applying the += operator to integers or string objects, for example, is interpreted by each of these objects in an individual manner. Obviously, the underlying implementation of += differs in every type. Yet, intuitively, we can predict what results are. Templates. A vector of integers, for example, reacts differently from a vector of string objects when it receives ...
17 comments
Read more

Explain Mutable Object Member or data member

When a data member is declared mutable, then it is legal to assign a value to it from a const member function. The following example may demonstrate when it is needed: class Buffer { void * data; //raw data buffer to be transmitted on the net size_t size; //size of the data mutable int crc; //used to verify that no errors occurred during transmission; //a mutable variable is allowed to be modified from a const //member function. public: //... int GetCrc() const; void Transmit() const; //copmutation of crc_val should be done here }; void f() { Buffer buffer; //...fill buffer with data buffer.Transmit(); //crc can be modified here; other members may not } Class buffer uses a data buffer transmitted via communication link after it has been filled. The filling process is quite slow and repetitive, so there's no point in calculating the value of crc every time a few bytes are appended to data. On the other hand, the receiving size has to get the right crc of the data in order ...
Post a Comment
Read more