Thread: Importance of interfaces

The specialty about interfaces is that you can have multiple interfaces be implemented by a single class. In standard Java inheritance you are only allowed to inherit from one super class (a fancy way of saying class you're inheriting stuff from). However, there are times you need to be able to treat that same object using two or more different perspectives, so interfaces were introduced to keep multiple inheritance out of Java. Other than that, I don't think there's any difference.

public class A
{}
 
public class B
{}
 
// this is an example of multiple inheritance. This is illegal in Java
public class C extends A,B
{}
 
public interface D
{}
 
public interface E
{}
 
// this has a similar effect to what's being done in class C, but is allowed in java.
public class F implements D,E
{}
 
// this is also allowed in Java
public class G extends A, implements D,E

As far as I know, Java is the only language to have this strange interface deal (C++ allows multiple inheritance). However, I do only know Java and C++, so it's not really a comprehensive list at all

Interfaces are important in many ways, from defining behavior across classes to facilitating maintenance, code reuse, and rearrangements in large projects. The reasoning why could probably fill up a book (and probably has), but suffice it to say the single inheritance rule in java that helloworld described limits a java programmer to write classes which inherit only from a single parent class. Interfaces allow one to write a behavior between classes that cannot be achieved by inheritance.

Suppose you have a class Animal, and your program has utilized this base class to create all sorts of Animals using inheritance - for example Human, Lion, Bear, Hawk, Bat, Bird, etc...How can you easily specify behaviors - such as making a Bat and Bird fly; specifying that Lion, Bear, and Hawk are predators; specify which animals are nocturnal - if it cannot be accomplished by inheritance? Interfaces.

Other more realistic examples can be found throughout the java API. This includes things like listener/callback type interfaces (if you are familiar with other languages which use function pointers). A real world example could be designing a program with the intention of keeping the user interface and algorithms separated - the connection between the two is provided via a interfaces. This design could allow the algorithms to be easier to adapt for different GUI's or programs - and vice versa - rather than being locked into the dependency of a certain class.

An interesting point about interfaces, their declaration and implementation gets inherited along with the super class.

public class Cat implements Predator
{}
 
public class Lion extends Cat  // by default, Lion also gets the interface Predator
{}

What else would you like to know about interfaces?

Creating your own interfaces is very useful in designing custom events, and if you have some common property that you want to force certain types of objects to have before they are allowed to be used by a method.

The best way to learn about how to use interfaces is to learn more about polymorphism and experimenting with interfaces /inheritance yourself. Look through the Java API to see if you can see why they chose to use an interface at a particular time and while other times they chose to use an actual class (abstract or not).

The deciding factors usually boils down to if you need that class/interface to have a super method that all inheriting objects need to have, but the implementation is the same (a class is a better choice here), if you need a non-static constant field in the super class (a class is a better choice here), or if you need that object to behave in multiple ways (an interface is a better choice here). There are tons of things to take into consideration, and a lot of times it doesn't matter which implementation you choose. In the words of one of my professors, "There is no one right answer, but there are a lot of wrong answers." All you need to do is find one that works, hopefully better than the bare minimum.

Using interfaces you can control a set of classes only if these classes implement the corresponding interfaces.And your method can take a parameter of interface type,then the method will be able to receive kinds of variables only if they implement the interface.Thanks to interface,you can design some framwork, in the super framwork,the template will be fexed.All you need to do is implementing the concrete method of the interface.

The memebers of the interface are public static final by default.And the member methods are public. Even thouth you don't explicitly qualified them as public. So if your interface is defined as follow:

   //interface 
  int count=0;
  String process();

then it means:

  //interface
  public static final count=0;
  public String process();

Notice that you'd not implement the interface like this:

  //implementation
 String process(){  // concrete operations}

Because you are reducing the accessibility of the method.If this,the method become package access which is not allowable.

Using interface you can declare method in another interface without declaring new interface. But make sure that you have implement write interface otherwise it will give you error message. Using interface you can declare abstract methods in an abstract base class, because interface only gives description of method when you use this method in your program.