JAVA abstract vs interface

by anil kumar Tue Aug 18, 2009 7:58 pm

Abstract class vs Interface

An abstract class can have shared state or functionality. An interface is only a promise to provide the state or functionality. A good abstract class will reduce the amount of code that has to be rewritten because it's functionality or state can be shared. The interface has no defined information to be shared
In java you can inherit from one (abstract) class to "provide" functionality and you can implement many interfaces to "ensure" functionality

A simple three line concept

Use an abstract class when you want to inherit only from the parent

Use an interface when you want to inherit from multiple sources

Use both when you want a basic behavior from the parent and extra features from other sources

Is there a performance overhead in using either an abstract class or an interface?

Abstract class is faster than interface

we write a program using abstract class in that abstract class
we declare abstract methods and variables.

if we want that methods and variable for another class we
extends that abstract class which method and variable we want
to declare eg: //take an example class shape

abstract class shape
{
int a,b,c;
String s1;
abstract area(int);
abstract area(int a, string s);

}

Here area is used every class ie square, rectangle, triangle
etc.. so which shape we want we extends this abstract. so it
is simple to compare of interface

In interface we declare all methods if not needed that method
that time also we must defined so it will take lot of
time and memory usage

Why we are? and when we are using Interfaces ?

Interfaces are useful when you do not want classes to inherit from unrelated classes just to get the required functionality. For example, let bird be a class with a method fly(). It will be ridiculous for an aeroplane to inherit from bird class just because it has the fly() method. Rather the fly() method should be defined as an interface and both bird and aeroplane should implement that interface.

When should I use an interface instead of an abstract class

Abstract class is an incomplete implementation of some concept. This incomplete implementation may be different in different context. Derived class implements the abstract class in its context.

Interface defines contract or standard. Implementation of the interface has to follow the contract or standard. Interfaces are more used to set these types of standards or contracts.

E.g. In an application there are different editors. There are different toolbars, which can be used on these editors like navigation tool bar. In order to use this tool bar editor should implement that functionality.

So there can be interfaces like - navigation - search – save and modify

if an editor implements all three all toolbars will be enabled. if one then only one will be enable. and implementation of these interface differs from context to context.

In the same example myAbstractEditor can be a class, which implements basic functionality of the editor. Where setting different controls, getting values from them can be abstract, which will depend on editor to editor.