We’ll first discuss what Interfaces and Abstract Classes are all about to understand the differences between the two more clearly and completely.
Interface: Java Interfaces are equivalent to protocols. They basically represent an agreed-upon behavior to facilitate interaction between unrelated objects. For example, the buttons on a Remote Controller form the interface for outside world to interact with TV. How this interface is implemented by different vendors is not specified and you’re hardly aware of or bothered about how these buttons have been implemented to work internally. Interface is plainly a contract between the producer and the consumer. How the producer implements the exposed behavior is normally not cared by the consumer.
In Java, an Interface is normally a group of methods with empty bodies. You can have constant declarations in a Java Interface as well. A class that implements the interface agrees to the exposed behavior by implementing all the methods of the interface.
interface TVRemoteController{
void power();
void setChannel(int channelNumber);
void upChannel();
void downChannel();
void upVolume();
void downVolume();
……
}
A sample implementation of this interface by a vendor, say Sony:
public class SonyTVRemoteController implements TVRemoteController{
/*…this class can have other methods, properties as well …*/
……
void power(){
//implementation of power() method of the interface
}
void setChannel(int channelNumber){
//implementation of setChannel(int) method of the interface
}
//similarly, implementation of other methods of the interface
……
}
Implementing an interface means the class will support at least the exposed behavior. It can definitely add any number of extra behaviors/properties for its clients. That’s why few Remote Controllers have hell lot of buttons :-)
Abstract Class: In Java, abstract class is a class which has been declared ‘abstract’. By declaring ‘abstract’ we ensure that the class can’t be instantiated. Why to have such a class then? Because, you would not be having implementation of all the methods in that class and you need to leave it to the subclass to decide how to implement them. In this case, there is no point instantiating an incomplete class.
An abstract method is a method which doesn’t have any implementation. If a class has even a single abstract method, then you got to declare the class ‘abstract’. Though, you don’t need to have at least one abstract method to declare a class abstract. You can declare a complete class as ‘abstract’ as well. This practice is seldom used. One possible reason may be that you never want your clients to instantiate your class directly even though you’ve already provided default implementation of all the methods. Strange! Yeah… it is. The designer of such a class may like to provide the default implementation of at least one method just to serve as a template (and not the actual implementation) for the client and thus making the class incomplete. So, a client first needs to subclass and implement the method(s) by overriding them. Now the subclass will be a concrete/complete class. Does it make some sense? Okay… Let me try to give another example. Think of a hypothetical situation, where you need to design a class, which will have ‘n’ methods and ‘n’ clients, where every single client wants default implementation of ‘n-1’ methods and it needs to implement only one (unique to every client) of the methods. In such a situation, you may not like to declare any of the methods ‘abstract’ as it’ll be required to be a non-complete method only for one of the clients and a complete implementation for other ‘n-1’ clients. If you declare it ‘abstract’ then every client will need to implement it and you’ll end up getting ‘n-1’ same piece of code. On the other hand, if you don’t declare ‘abstract’ then you simply need to override this method in corresponding sub class. Since, the base class is incomplete in all the ‘n’ cases. Assuming that this class will have only these many forms of usage, you’ll never require having an instance of it. That’s why you would declare it ‘abstract’. Confused? Read this paragraph once more :-)
public abstract class SampleAbstractClass{
//…fields
……
//…non-abstract methods, if any
……
//…abstract method, if any J
abstract void sampleAbstractMethod(); //… ends with ‘;’
}
public class SubClassOfSampleAbstractClass extends SampleAbstractClass{
//… fields, and non-abstract methods (if any)
……
//…implementation of the abstract method
void sampleAbstractMethod(){
……
}
}
Difference between Interfaces and Abstract Classes: From the language perspective, there are several differences, few of them are:-
- An abstract class may contain fields, which are not ‘static’ and ‘final’ as is the case with interfaces.
- It may have few (or all) implemented methods as well, whereas Interfaces can’t have any implementation code. All the methods of an interface are by default ‘abstract’. Methods/Members of an abstract class may have any visibility: public, protected, private, none (package). But, those of an interface can have only one type of visibility: public.
- An abstract class automatically inherits the Object class and thereby includes methods like clone(), equals(), etc. There is no such thing with an interface. Likewise, an abstract class can have a constructor, but an interface can’t have one…
- Another very famous difference is that Interfaces are used to implement multiple inheritance in Java as a class in Java can explicitly have only one super class, but it can implement any number of interfaces… blah blah… :-)
From the performance perspective, the different is that Interfaces may be little slower as they require extra indirection to find the corresponding method in the actual class. Though, modern JVMs have already made that difference very little.
If you want to add a new method to an interface, then you either need to track all the classes implementing that interface or you’ll extend that interface to make a new interface having that extra method(s). In case of an abstract class, you’ll simply add the default implementation of that method and all the code will continue to work.
Many differences are listed already, but the main difference lies in the usage of the two. They are not rivals, but in most of the cases they are complimentary. We need to understand when to use what.
When to use an Interface: it asks you to start everything from scratch. You need to provide implementation of all the methods. So, you should use it to define the contract, which you’re unsure of how the different vendors/producers will implement. So, you can say that Interfaces can be used to enforce certain standards.
When to use an Abstract Class: it is used mostly when you’ve partial implementation ready with you, but not the complete. So, you may declare the incomplete methods as ‘abstract’ and leave it to the clients to implement it the way they actually want. Not all the details can be concrete at the base class level or different clients may like to implement the method differently.
When to use both: if you want to implement multiple inheritance where you have the luxury of providing partial implementation as well. You’ll then put all that code in an abstract class (this can be a concrete class as well… but here we assume that the class is also only partially implemented and hence an abstract class), extend that class, and implement as may interfaces as you want.
Update[June 25, 2008]: Do interfaces in Java really inherit the Object class? If NOT then how do we manage to call Object methods on the references of an interface type? Read more in this article - Do Interfaces inherit the Object class in Java?
Liked the article? You may like to Subscribe to this blog for regular updates. You may also like to follow the blog to manage the bookmark easily and to tell the world that you enjoy GeekExplains. You can find the 'Followers' widget in the rightmost sidebar.
........................................................................................................................................................................
Introduction
In this article along with the demo project I will discuss
Interfaces versus
Abstract classes. The concept of
Abstract classes and
Interfaces is a bit confusing for beginners of Object Oriented programming. Therefore, I am trying to discuss the theoretical aspects of both the concepts and compare their usage. And finally I will demonstrate how to use them with C#.
Background
An
Abstract class without any implementation just looks like an
Interface; however there are lot of
differences than similarities between an
Abstract class and an
Interface. Let's explain both concepts and compare their similarities and
differences.
What is an Abstract Class?
An
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 sub
classes. In simple words, it is a kind of contract that forces all the sub
classes 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 sub
classes 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.
Both Together
When we create an
interface, we are basically creating a set of methods without any implementation that must be overridden by the implemented
classes. The advantage is that it provides a way for a
class to be a part of two
classes: one from inheritance hierarchy and one from the
interface.
When we create an
abstract class, we are creating a base
class that might have one or more completed methods but at least one or more methods are left uncompleted and declared
abstract. If all the methods of an
abstract class are uncompleted then it is same as an
interface. The purpose of an
abstract class is to provide a base
class definition for how a set of derived
classes will work and then allow the programmers to fill the implementation in the derived
classes.
There are some similarities and
differences between an
interface and an
abstract class that I have arranged in a table for easier comparison:
Feature
| Interface
| Abstract class
|
Multiple inheritance
| A class may inherit several interfaces.
| A class may inherit only one abstract class.
|
Default implementation
| 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.
|
| Access Modfiers | 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 |
Core VS Peripheral
| Interfaces are used to define the peripheral abilities of a class. In other words both Human and Vehicle can inherit from a IMovable interface.
| An abstract class defines the core identity of a class and there it is used for objects of the same type.
|
Homogeneity
| If various implementations only share method signatures then it is better to use Interfaces.
| If various implementations are of the same kind and use common behaviour or status then abstract class is better to use.
|
Speed
| Requires more time to find the actual method in the corresponding classes.
| Fast
|
Adding functionality (Versioning)
| If we add a new method to an Interface then we have to track down all the implementations of the interface and define implementation for the new method.
| If we add a new method to an abstract class then we have the option of providing default implementation and therefore all the existing code might work properly.
|
| Fields and Constants | No fields can be defined in interfaces | An abstract class can have fields and constrants defined |
Using the Code
Let me explain the code to make it a bit easier. There is an
Employee abstract class and an
IEmployee interface. Within the
Abstract class and the
Interface entity I am commenting on the
differences between the artifacts.
I am testing both the
Abstract class and the
Interface by implementing objects from them. From the
Employee abstract class, we have inherited one object:
Emp_Fulltime. Similarly from
IEmployee we have inherited one object:
Emp_Fulltime2.
In the test code under the GUI, I am creating instances of both
Emp_Fulltime and
Emp_Fulltime2 and then setting their attributes and finally calling the
calculateWage method of the objects.
Abstract Class Employee
Collapseusing System;
namespace AbstractsANDInterfaces
{
public abstract class Employee
{
protected String id;
protected String lname;
protected String fname;
public abstract String ID
{
get;
set;
}
public abstract String FirstName
{
get;
set;
}
public abstract String LastName
{
get;
set;
}
public String Update()
{
return "Employee " + id + " " +
lname + " " + fname +
" updated";
}
public String Add()
{
return "Employee " + id + " " +
lname + " " + fname +
" added";
}
public String Delete()
{
return "Employee " + id + " " +
lname + " " + fname +
" deleted";
}
public String Search()
{
return "Employee " + id + " " +
lname + " " + fname +
" found";
}
public abstract String CalculateWage();
}
}Interface Employee
Collapse using System;
namespace AbstractsANDInterfaces
{
public interface IEmployee
{
String ID
{
get;
set;
}
String FirstName
{
get;
set;
}
String LastName
{
get;
set;
}
String Update();
String Add();
String Delete();
String Search();
String CalculateWage();
}
}Inherited Objects
Emp_Fulltime:
Collapse using System;
namespace AbstractsANDInterfaces
{
public class Emp_Fulltime : Employee
{
public Emp_Fulltime()
{
}
public override String ID
{
get
{
return id;
}
set
{
id = value;
}
}
public override String FirstName
{
get
{
return fname;
}
set
{
fname = value;
}
}
public override String LastName
{
get
{
return lname;
}
set
{
lname = value;
}
}
public new String Add()
{
return base.Add();
}
public new String Delete()
{
return base.Delete();
}
public new String Search()
{
return base.Search();
}
public new String Update()
{
return base.Update();
}
public override String CalculateWage()
{
return "Full time employee " +
base.fname + " is calculated " +
"using the Abstract class...";
}
}
}Emp_Fulltime2:
Collapse using System;
namespace AbstractsANDInterfaces
{
public class Emp_fulltime2 : IEmployee
{
protected String id;
protected String lname;
protected String fname;
public Emp_fulltime2()
{
}
public String ID
{
get
{
return id;
}
set
{
id = value;
}
}
public String FirstName
{
get
{
return fname;
}
set
{
fname = value;
}
}
public String LastName
{
get
{
return lname;
}
set
{
lname = value;
}
}
public String Add()
{
return "Fulltime Employee " +
fname + " added.";
}
public String Delete()
{
return "Fulltime Employee " +
fname + " deleted.";
}
public String Search()
{
return "Fulltime Employee " +
fname + " searched.";
}
public String Update()
{
return "Fulltime Employee " +
fname + " updated.";
}
public String CalculateWage()
{
return "Full time employee " +
fname + " caluculated using " +
"Interface.";
}
}
}Code for Testing
Collapse
private void InterfaceExample_Click(object sender,
System.EventArgs e)
{
try
{
IEmployee emp;
Emp_fulltime2 emp1 = new Emp_fulltime2();
emp = emp1;
emp.ID = "2234";
emp.FirstName= "Rahman" ;
emp.LastName = "Mahmoodi" ;
MessageBox.Show(emp.Add().ToString());
MessageBox.Show(emp.CalculateWage().ToString());
}
catch(Exception ex)
{
MessageBox.Show(ex.Message);
}
}
private void cmdAbstractExample_Click(object sender,
System.EventArgs e)
{
Employee emp;
emp = new Emp_Fulltime();
emp.ID = "2244";
emp.FirstName= "Maria" ;
emp.LastName = "Robinlius" ;
MessageBox.Show(emp.Add().ToString());
MessageBox.Show(emp.CalculateWage().ToString());
}Conclusion
In the above examples, I have explained the
differences between an
abstract class and an
interface. I have also implemented a demo project which uses both
abstract class and
interface and shows the
differences in their implementation.
Posts
