3
Interfaces An interface is a “pure” abstract class. The intent of an interface is to specify a set of methods that a concrete class will honor. In return, the class that implements the interface is regarded as a subtype of the interface type, and gets “polymorphic privileges”. The big deal is that a new class can implement several interfaces. Interfaces have no data members (except static final) or method bodies. Interfaces are a good idea. CS 340 3

5
Technical Details Use the interface keyword rather than class. An interface usually sits in its own.java file. Use public or nothing (making it friendly). private and protected aren’t allowed. To implement, write a class using the implements keyword. Interface methods are always public. CS 340 5

6
Technical Details, cont Note there is no constructor given. The abstract keyword isn’t used for the methods. The methods are automatically public. CS 340 6

10
Other Interface Issues You can inherit from an interface to create a new interface. A single class can implement several interfaces simultaneously (Java’s version of multiple inheritance). This is OK, since interfaces have no data or method code that could conflict. You must watch out for method name clashes, though. CS 340 10

12
Inner Classes It’s possible (and sometimes encouraged!) to define one class within another. This provides another way to group classes that work closely together. Inner classes can be “shielded” so that they are unknown to the outside world. Often inner classes are used to hide a class-specific implementation of an external interface. CS 340 12

13
A Primitive Iterator This provides a way to access elements in “container classes.” If everyone uses the same interface, new container class types are interchangeable. public interface Selector { boolean end(); Object current(); void next(); } CS 340 13

17
Sequence and Selector This is quite similar to Java’s use of Iterator The inner class can access the outer class (e.g., get at the array), implement a public interface, and remain private, and specialized. We might write a tree-based container, using the same Selector interface. It would be easy for clients to switch between the two, if necessary for performance reasons. CS 340 17

18
Sequence and Selector (cont.) Sequence is pretty primitive, eh? How would you improve it to be more type-specific? handle overflow more gracefully? access specific elements directly? CS 340 18

19
More on Inner Classes Look again at SSelector, for example the line return objects[i]; in the method current(). How does the SSelector object know which Sequence object it “belongs to”? It holds a reference to the object that created it. The compiler takes care of these details. You can get this reference by saying outerClass.this You can’t create an inner class object unless you have an outer class object to start with, unless… CS 340 19

20
Static Inner Classes You don’t need an object of the outer class type to create an object of a static inner class type. Of course you can’t access an outer class object with a static inner class type (there is no this). A bottle of Rolling Rock to the first person providing a convincing example of where you’d want to do this! CS 340 20

21
Anonymous Inner Classes If we never need to invoke the name of an inner class type, we can make the inner class anonymous. This is a common idiom in Java, but somewhat confusing. It is much used, for example, in GUI programming with Swing listener classes. CS 340 21

23
Random Facts on Inner Classes.class files are created, using the convention OuterClassName$InnerClassName.class Anonymous inner classes are in files like OuterClassName$1 You can nest inner classes indefinitely, but things quickly become confusing. You can have multiple inner classes implementing different interfaces. CS 340 23