Chapter 12
Interfaces

TIP: While all fields will be created as public, final, and static, you do not need to explicitly state this in the field declaration. All fields default to public, static, and final regardless of the presence of these modifiers. It is, however, a good practice to explicitly define all fields in interfaces as public, final, and static to remind yourself (and other programmers) of this fact.

public interface Product {
   //This variable is static and final.
   static final String MAKER = "My Corp";

   //This variable is also static and final by default, even though not 		   //stated explicitly.
   String PHONE = "555-123-4567";

   public int getPrice(int id);
}

Implementing Interfaces

Now that you know how to create interfaces, let's examine how they are used in developing classes. Listing 12.4 shows an example of a class that implements our Product interface.

Listing 12.4Implementing an Interface

class Shoe implements Product {
     public int getPrice(int id) {
          if (id == 1)
               return(5);
          else
               return(10);
     }
     public String getMaker() {
          return(MAKER);
     }
}

Of course, the code in the class can deal with functions other than those relating to the interface (such as the getMaker() method). But, in order to fulfill the requirements of implementing the Product interface, the class must override the getPrice(int) method.

Overriding Methods

Declaring a method in an interface is a good practice. However, the method cannot be used until a class implements the interface and overrides the given method.

TIP: Remember that if you implement an interface, you are required to override all methods declared in the interface. Failure to do so will make your class abstract.

Modifiers

As discussed earlier, methods declared in interfaces are by default assigned the public level of access. Consequently, because you cannot override a method to be more private than it already is, all methods declared in interfaces and overridden in classes must be assigned the public access modifier, unless they are explicitly made less public in the interface.

Of the remaining modifiers that may be applied to methods, only native and abstract may be applied to methods originally declared in interfaces.

Parameter List

Interface methods define a set a of parameters that must be passed to the method. Consequently, declaring a new method with the same name but a different set of parameters than the method declared in your interface overloads the method, not overrides it.

While there is nothing wrong with overloading methods declared in interfaces, it is also important to implement the method declared in the interface. Therefore, unless you declare your class to be abstract, you must override each method, employing the same parameter signature as in your interface (see Listing 12.5). By the way, only one method satisfies the run() method required for Runnable.

Listing 12.5Runner.java--A Class that Implements Runnable and Has Two run Methods

public void Runner implements Runnable {

//This method overloads the run() method;it does not
//fulfill the requirements for Runnable.
public void run(int max){
   int count =0;
   while (count++<max){
      try{
         Thread.sleep(500);
      } catch (Exception e){}
   }
}

//This method fulfills the requirement for Runnable.
//You must have this method.
public void run(){
   while (true){
      try{
         Thread.sleep(500);
      } catch (Exception e){}
   }
}
}

If the method String createName(int length, boolean capitalized) is declared in an interface, here are some valid and invalid examples of how to override it. The invalid methods can exist in addition to the valid ones, but will not be related to the interface:

Valid	Invalid
String createName(int a, boolean b)	String createName	(boolean capitalized, int length)
String createName(int width,	String boolean formatted)	createName(int length)

Body

When creating a class that implements an interface, one of your chief concerns will be creating bodies for the methods originally declared in the interface. Unless you decide to make the method native, it is necessary to create the body for every method originally declared in your interface if you do not want to make your new class abstract.

The actual implementation and code of the body of your new method is entirely up to you. This is one of the good things about using interfaces. While the interface ensures that in a non-abstract class, its methods will be defined and will return an appropriate data type, the interface places no further restrictions or limitations on the method bodies.

Using Interfaces from Other Classes

You've learned how to create interfaces and build classes based on interfaces. However, interfaces are not useful unless you can develop classes that will either employ the derived classes or the interface itself.

Using an Interfaces Fields

Although the fields of an interface must be both static and final, they can be extremely useful in your code.

The following example demonstrates that any variable from an interface can be referenced by using the same dot notation you use with classes. That means you can use java.awt.image.ImageConsumer.COMPLETESCANLINES just as with the class java.awt.Event you use with java.awt.Event.MOUSE_DOWN. This provides you with access to constants. Listing 12.6 shows an example of another ImageConsumer variable being used.

Listing 12.6Using the Constant Fields of an Interface

class MyImageHandler {
/* The java.awt.image.ImageConsumer interface defines certain constants to serve as indicators. STATICIMAGEDONE, which  is set to equal 3, informs the consumer that the image is complete.*/
     ImageConsumer picture;

     void checkStatus(boolean done) {
          if (done)
              picture.imageComplete(ImageConsumer.STATICIMAGEDONE);
          }
}

Using Interfaces as Types

One of the most important features of an interface is that it can be used as a data type. An interface variable can be used just as you would any class.

As a Parameter Type In Listing 12.7, you create a simple application that employs the Shoe class developed earlier. Because the Shoe class implements the Product interface, you may deal with the instances of the Shoe class either as standard Shoe objects or as objects based on the Product interface. Although both approaches produce the same results, treating the instance as an object based on the Product interface provides you with a more flexible and useful way of using the resources provided by the Product interface.

Listing 12.7Using an Interface as a Parameter Type

class Store {
     static Shoe hightop;

     public static void init() {
            hightop = new Shoe();
     }

     public static void main(String argv[]) {
            init();
            getInfo(hightop);
            orderInfo(hightop);
           }

     public static void getInfo(Shoe item) {
          System.out.println("This Product is made by "+ item.MAKER);
          System.out.println("It costs $" + item.getPrice(1) + `\n');
     }

     public static void orderInfo(Product item) {
          System.out.println("To order from " +item.MAKER + " call " +                               item.PHONE + ".");
          System.out.println("Each item costs $" + item.getPrice(1));
     }
}

Output In the following example, the getInfo() method treats hightop as a simple class with certain methods and fields. However, the interesting example is orderInfo(), which extracts almost the same information without knowing anything about a Shoe. Because a Shoe meets the requirements of a Product, you are able to implicitly cast a Shoe to become a Product. As a result, because you know that the Product interface declares certain features, you can be sure that these features, such as the getPrice() method, are present in the parameter item:

C:\dev>\jdk\java\bin\java Store
This Product is made by My Corp
It costs $5
To order from My Corp call 555-123-4567.
Each item costs $5

NOTE: Notice that in treating hightop as a Product, you are implicitly casting it as a new data type without specifically stating so in your code. While the compiler has no trouble doing this, you could substitute that line of code in the Store class for the following:

orderInfo( (Product)hightop);

This statement would accomplish the same goal and is often easier for other programmers to read, because it shows that orderInfo() accepts a Product, not a Shoe as its argument.

Listing 12.8Using an Interface as a Type to Deal with Several Classes

interface Product {
     String MAKER = "My Corp";
     static final String PHONE = "555-123-4567";
     public int getPrice(int id);
     public void showName();
}
class Book implements Product {
     public int getPrice(int id) {
          if (id == 1)
               return(20);
          else
               return(30);
     }
     public void showName() {
           System.out.println("I'm a book!");
     }
}
class Shoe implements Product {
     public int getPrice(int id) {
          if (id == 1)
               return(5);
          else
               return(10);
     }
     public void showName() {
           System.out.println("I'm a shoe!");
     }
}
class store {
     static Shoe hightop;
     static Book using_java;

     public static void init() {
          hightop = new Shoe();
          using_java = new Book();
     }

     public static void main(String argv[]) {
          init();
          orderInfo(hightop);
          orderInfo(using_java);
     }

     public static void orderInfo(Product item) {
          item.showName();
          System.out.println("To order from " + item.MAKER + " call " +                          item.PHONE + ".");
          System.out.println("Each item costs $" + item.getPrice(1));
     }
}

Output:
C:\dev>\jdk\java\bin\java Store
I'm a shoe!
To order from My Corp call 555-123-4567.
Each item costs $5
I'm a book!
To order from My Corp call 555-123-4567.
Each item costs $20
o the constructor method.

Exceptions

In order for an interface method to throw an exception, the exception type (or one of its superclasses) must be listed in the exception list for the method as defined in the interface. However, when dealing with interface methods, exceptions are an exception. Here are the rules for overriding methods that throw exceptions:

• The new exception list may only contain exceptions listed in the original exception list, or subclasses of the originally listed exceptions.

• The new exception list does not need to contain any exceptions, regardless of the number listed in the original exception list. (This is because the original list is inherently assigned to the new method.)

• The new method may throw any exception listed in the original exception list or derived from an exception in the original list, regardless of its own exception list.

In general, the exception list of the method which is declared in the interface, not the re- declared method, determines which expectations can and cannot be thrown. In other words, when a re-declared method changes the exception list, it cannot add any exceptions that are not included in the original interface declaration.

As an example, examine the interface and method declarations in Listing 12.9.

Listing 12.9Alternate Exception Lists

interface Example {
     public int getPrice(int id) throws java.lang.RuntimeException;
}

class User implements Example {
public int getPrice(int id) throws java.awt.AWTException {   // Illegal - Reason 1
// java.awt.AWTException is not a subclass  ofjava.lang.RuntimeException
     /// method body
     }
     public int getPrice(int id) {
          if (id == 6)
               throw new java.lang.IndexOutOfBoundsException();                                 // Legal - Reason 2
                         // IndexOutOfBoundsException is derived from                                // RuntimeException
          else
               ...
     }
     public int getPrice(int id) throws java.lang.IndexOutOfBoundsException {                       // Legal - Reason 1
                    // IndexOutOfBoundsException is derived from 
	             //RuntimeException
          if (id == 6)
               throw new java.lang.ArrayIndexOutOfBoundsException();                             // Legal - Reason 3
                    //      ArrayIndexOutOfBoundsException is derived from  	             //IndexOutOfBoundsException
          ...
}