Java in a Nutshell, 6th Edition

1. Extending interfaces
   
2. Interfaces may extend other interfaces, and, like a class definition, an interface definition may include an extends clause. When one interface extends another, it inherits all the abstract methods and constants of its superinterface and can define new abstract methods and constants. Unlike classes, however, the extends clause of an interface definition may include more than one superinterface. For example, here are some interfaces that extend other interfaces:
   
3. 
   
4. public interface Positionable extends Centered {
   
5.     void setUpperRightCorner(double x, double y);
   
6.     double getUpperRightX();
   
7.     double getUpperRightY();
   
8. }
   
9. public interface Transformable extends Scalable, Translatable, Rotatable {}
   
10. public interface SuperShape extends Positionable, Transformable {}

复制代码

1. Defining an Interface
   
2. An interface definition is much like a class definition in which all the methods are abstract and the keyword class has been replaced with interface. For example, the following code shows the definition of an interface named Centered. A Shape class, such as those defined earlier in the chapter, might implement this interface if it wants to allow the coordinates of its center to be set and queried:
   
3. 
   
4. public interface Centered {
   
5.     void setCenter(double x, double y);
   
6.     double getCenterX();
   
7.     double getCenterY();
   
8. }
   
9. A number of restrictions apply to the members of an interface:
   
10. 
    
11. An interface contains no implementation whatsoever. All methods of an interface are implicitly abstract and must have a semicolon in place of a method body. The abstract modifier is allowed but, by convention, is usually omitted. Since static methods may not be abstract, the methods of an interface may not be declared static .
    
12. 
    
13. An interface defines a public API. All members of an interface are implicitly public, and it is conventional to omit the unnecessary public modifier. It is an error to define a protected or private method in an interface.
    
14. 
    
15. An interface may not define any instance fields. Fields are an implementation detail, and an interface is a pure specification without any implementation. The only fields allowed in an interface definition are constants that are declared both static and final.
    
16. 
    
17. An interface cannot be instantiated, so it does not define a constructor.
    
18. 
    
19. Interfaces may contain nested types. Any such types are implicitly public and static. See Section 3.10 later in this chapter.

复制代码

1. Example 3-7. Defining and using a static member interface
   
2. // A class that implements a stack as a linked list
   
3. public class LinkedStack {
   
4.     // This static member interface defines how objects are linked
   
5.     // The static keyword is optional: all nested interfaces are static
   
6.     public static interface Linkable {
   
7.         public Linkable getNext();
   
8.         public void setNext(Linkable node);
   
9.     }
   
10. 
    
11.     // The head of the list is a Linkable object
    
12.     Linkable head;  
    
13. 
    
14.     // Method bodies omitted
    
15.     public void push(Linkable node) { ... }
    
16.     public Object pop() { ... }
    
17. }
    
18. 
    
19. // This class implements the static member interface
    
20. class LinkableInteger implements LinkedStack.Linkable {
    
21.     // Here's the node's data and constructor
    
22.     int i;
    
23.     public LinkableInteger(int i) { this.i = i; }
    
24. 
    
25.     // Here are the data and methods required to implement the interface
    
26.     LinkedStack.Linkable next;
    
27.     public LinkedStack.Linkable getNext() { return next; }
    
28.     public void setNext(LinkedStack.Linkable node) { next = node; }

复制代码

1. Example 3-8. An iterator implemented as a member class
   
2. import java.util.Iterator;
   
3. 
   
4. public class LinkedStack {
   
5.     // Our static member interface
   
6.     public interface Linkable {
   
7.         public Linkable getNext();
   
8.         public void setNext(Linkable node);
   
9.     }
   
10.    
    
11.     // The head of the list
    
12.     private Linkable head;  
    
13.    
    
14.     // Method bodies omitted here
    
15.     public void push(Linkable node) { ... }
    
16.     public Linkable pop() { ... }
    
17.    
    
18.     // This method returns an Iterator object for this LinkedStack
    
19.     public Iterator<Linkable> iterator() { return new LinkedIterator(); }
    
20.    
    
21.     // Here is the implementation of the Iterator interface,
    
22.     // defined as a nonstatic member class.
    
23.     protected class LinkedIterator implements Iterator<Linkable> {
    
24.         Linkable current;
    
25.         // The constructor uses the private head field of the containing class
    
26.         public LinkedIterator() { current = head; }
    
27.         // The following 3 methods are defined by the Iterator interface
    
28.         public boolean hasNext() {  return current != null; }
    
29.         public Linkable next() {
    
30.             if (current == null) throw new java.util.NoSuchElementException();
    
31.             Linkable value = current;
    
32.             current = current.getNext();
    
33.             return value;
    
34.         }
    
35.         public void remove() { throw new UnsupportedOperationException(); }
    
36.     }
    
37. }

复制代码