Java instance vs Abstract Classes and methods

An interface defines a new secondary datatype in Java. It (interface) is a group of final variables and abstract methods only.

The members of an interface are "public" by default. Infact private and protected modifiers are not allowed in an interface.

An interface is a reference type only its objects cannot be created.

An interface can inherit another interface but cannot inherit any class.

A class cannot inherit any interface but it (a class) can implement zero to many interfaces.

If a class implements interfaces then 1) It has to override all the abstract methods of all the implemented interfaces.

2) Type compatibilty gets created between the interface and the class. It allows an interface reference can refer to object of implementing class.

interface Iface
{
  int x = 3;//final and public by default
  void f();//abstract and public by default
}

interface AnotherI extends Iface
{ 
  //more declarations possible here
}

class InterfaceDemo implements Iface
{
 public void f()
 {
   int i;
   for(i =0 ; i< x; i++)
     System.out.println("Interfaces are widely used");
 }

 public static void main(String args[])
 {
   Iface ref = new InterfaceDemo();
   ref.f();//allowed
   //ref.newMethodsOfClass();//not allowed
 }
}

The main difference is that you can only extend one class but you can implement multiple interfaces.

This can be important if you want to (for example) implement a listener while also extending another class. Note though that in many cases you are better off using an anonymous inner class to do the listening.

Java does not support polymorphic inheritance - where a class can extend multiple classes. This choice was made to avoid the problems associated with hierarchical conflict resolution (where a method exists in both parent classes - which one do you use?). In simple parlance, in java there can only be one "is a" relationship.

However, to allow a form of polymorphism, interfaces were introduced. These are hollow templates for which the class must provide implementations, and offer a way of creating a "look like a" relationship. While only allowing an object to "be" a instance of one (parent) class, it may "look like" any number of interfaces.

By taking inheritance out of interfaces, it allows cross-cutting concepts to be handled - ie where classes of completely different inheritance structures may nevertheless share some abstract similarity. A good example from the JDK is Serializable, which is a marker interface (one without methods). Virtually any class has the possibility to be serializable, but virtually all serializable classes don't share any of their inheritance hierarchy. This concept couldn't be handled with abstract classes - you have to step out of the class hierarchy to achieve it - ie interfaces is the only way to do it.