1. Interfaces

Introduction to Interfaces

• An interface is a group of related method signatures which provide a guarantee of the behavior a class will provide.
• For example:

• A Java interface declares a set of methods that an object must define
• An interfaces can be considered a contract that a class is guaranteeing to uphold
  
• This contract is that any class that implements the interface must define all the methods in interface
  
  • None of the methods in the interface have a body*
  • (*unless they are defined to be default or static (a new feature since Java 8))
  • All interface methods are implicitly public and abstract 
  • (*unless they are defined to be default or static (a new feature since Java 8))
  • Thus, you can omit the modifiers public and abstract from your method signatures
    
  • Any class that implements an interface must define the bodies of all the abstract methods contained in the interface.
    
• In addition, an interface may define constant variables.
• If you declare a variable inside of an interface, that variable automatically become public, static and final -- even if you do not explicitly declare it to be so.
• Thus, you can omit the modifiers public, static and final from your variable declaration.
  
• To inherit from an interface, you must use the keyword implements

• When a class implements an interface there is a formal guarantee about the behavior it will provide
  
• If a class implements an interface, all methods defined by that interface must appear in its source code before the class will compile.
• The next example shows an interface for a programmer-defined system with a method that any object must implement for drawing

Example Interface

• Here is an example of a simple interface:

  public interface Drawable {
      public static final int FILLED = 0;
      public static final int UNFILLED = 1;
      public void draw();
  }
  

• Provides two integer constants
• Declares a single abstract method named draw()
• Note that the interface does not provide any code for the method
• An interface can only provide a method signature (unless using the keyword default as described below)
  

Example Interface Implementation

• A class that implements an interface must:
  1. Declare that it is implementing the interface

     implements Drawable

  2. Provide code for all the methods of the interface
• Here is an example class implementing the Drawable interface shown above:

  class Shape implements Drawable {
      public void draw() {
          System.out.println("Drawing a Shape.");
      }
  }
  

Writing Custom Interfaces

• Declaring an interface is similar to declaring a class
• You use the keyword interface instead of class
• General syntax:

  public interface InterfaceName {
      [public] [static] [final] dataType CONSTANT_NAME = value;
      returnType methodName(parameterList);
  }
  

• Where:
  • InterfaceName: the name you make up for the interface
  • dataType: the type of constant
  • CONSTANT_NAME: the name you make up for the constant
  • value: the value of the constant
  • returnType: the type of value returned by the method, or void for no return value
  • methodName: the name you make up for the method
  • parameterList: the types and names of the parameters
• The constant variables and abstract methods are optional
• For example:

  public interface Drawable {
      public static final int FILLED = 0;
      public static final int UNFILLED = 1;
      public void draw();
  }
  

• Declares an abstract method named draw()
  • You cannot write the implementation of the method in the interface
  • Instead, you write the implementation of the method in any class that implements the interface
• All methods are public and abstract by default
• Similarly, all constants are public static final by default:
  • Using the keywords public static final is optional
  • Though optional, they help to document the scope
• Any interface method that is implemented becomes an instance method

image source

Extending Interfaces

• You can derive new interfaces from an existing one just like classes can extend classes
• One difference is that an interface can extend multiple interfaces
• Syntax:

  public interface InterfaceName
      [extends SuperInterface1 [, SuperInterface2]...] { }
  

• Where:
  • InterfaceName: the name you make up for the interface
  • SuperInterfaceX: the name of the interface being extended
• For example, we could split our Drawable interface into two superinterfaces and one subinterface
• The superinterfaces now contain the constants:

  interface DrawingConstants {
      public static final int FILLED = 0;
  }
  
  interface DrawingConstants2 {
      public static final int UNFILLED = 1;
  }
  

• The subinterface contains the method declaration:

  interface Drawable
          extends DrawingConstants, DrawingConstants2 {
      public void draw();
  }
  

• The new Drawable has the same capabilities as the old Drawable

Implementing Interfaces

• Any class can choose to implement zero or more interfaces
• Syntax:

  public class ClassName [extends SuperClass]
      [implements Interface1 [, Interface2]...] { }
  

• Where:
  • ClassName: the name you make up for the class
  • SuperClass: the name of the parent class
  • InterfaceX: the name of the interface being implemented
• Classes implementing an interface add the keyword implements in the class header
• After the implements keyword, code a comma-delimited list of interface names
• For example:

  public class Map implements Drawable
  

• Class Map must now implement the method draw()
• Note that you can refer to a constant declared in the interface without the interface name if you implement the interface

  int filled = UNFILLED;

• A class that implements an interface must implement all methods of the interface:

  public class Map implements Drawable {
      int filled = UNFILLED;
      public void draw() {
          System.out.println("Drawing a Map.");
      }
  }
  

Abstract Classes vs. Interfaces

• Abstract classes and interfaces have many similarities and differences
• Both abstract classes and interfaces allow you to define constants
• In addition, both abstract classes and interfaces allow you to declare abstract methods
• These similarities mean that interfaces can sometimes be used instead of an abstract class

Advantages of an Abstract Class

• An abstract class can have instance variables while an interface cannot
• An abstract class can define regular methods while interfaces cannot
  

Advantages of an Interface - Multiple Inheritance

• In Java, a class can only inherit from (extend) one class to avoid what is known as the "diamond problem" or sometimes "the deadly diamond of death" (Yikes!)
  
• The diamond problem can occur when two classes define methods with identical signatures
• If a subclass inherits from both these classes and tries to invoke one of the two methods, it will not be clear which method should be invoked (the one defined in the first class or the second class)
  
• However, a class can directly implement many interfaces
• Because (most) methods in interfaces are abstract, and thus have no bodies, it will be the job of any class extending the interface to define the body of the method
• Additionally, interfaces can inherit from other interfaces
  
• Recall that to inherit from more than one interface, a class can give a comma-separated list of interfaces in its signature, and use the keyword implements
  

• Similarly, an interface can provide a comma-separated list of other interfaces from which it inherits

When Will You Need Interfaces?

• You often need to implement interfaces in the Java API
• In particular, interfaces are used in coding graphical user interfaces
• You design interfaces most often when creating larger applications

More Information

• Oracle Interface Tutorial

• Open the Address.java and Employee.java classes
  
• Next, write over the contents of your Employee.java file with the following code:

• Notice that this class has now been made abstract, and contains an abstract method doesWork()
• Next, create two subclasses of Employee - Manager.java and Programmer.java.
• Copy and paste the below code into the Manager.java file and write the given methods:

• Copy and paste the below code into Programmer.java and implement the given methods:

• Next, add an Interface (File->New->Interface) to your project called AccountsPayable.java
• Copy and paste the below code into your file:

• Now, update Manager.java and Programmer.java so that they implement the AccountsPayable interface.
• You should not get an error message for these two classes as they must define the methods defined in AccountsPayable.java in order to compile.
  
• Add the following comment and method signature to Manager.java under the Accessors section of the class:

• Then, write the method body as described in the comment.
• Next, add the following comment and method signature to Manager.java in the Additional Operations section of the class:

• Now implement the rest of the method body.
• In Programmer.java, add the following comment and method to the Accessor section of the class, and then fill in the method body:

• Finally, add the following comment and method to the Additional Operations section of the Programmer class, and then fill in the method body:

• Lastly, write over your EmployeeTest.java file with the following code:

2. Implementing the Comparable Interface and the CompareTo Method

• The best approach to writing this method is to start by comparing the most significant field (i.e. name for the Dog class)
• If these two fields are equal, then compare the next most significant field (i.e. age), and so on until you find an unequal field
  
• I would recommend calling the equals method as a first step to determine whether the two objects are equal.
• Below is an example of a compareTo method for the Dog class:
  

• Here is another example:
  

• When comparing primitive types inside of a compareTo method, use one of the static comparison methods defined within these Object classes:
• Integer.compare: compare two int values
• Double.compare: compare two double values
• Character.compare: compare two char values
• Boolean.compare: compare to boolean values

• You can now close Address.java.
• Inside of Employee.java, alter the class signature so that it implements the Comparable interface.
• Add the following method signature to the Employee.java class and implement compareTo as described in the comment:

• You can now close Employee.java
• Finally, replace EmployeeTest.java with the following code:

• Complete the implementation of BubbleSort
  
• When you are finished, run the program and verify that you get the output as shown in the example output below.
• Then, upload Address.java, Employee.java, and EmployeeTest.java to Canvas