Ok, whether you are sold or not, Java does not allow multiple inheritance. They say that a better idea is to use interfaces

Suppose you wanted to write general routine(s) that would work on many different types of objects... but you are not concerned with the state of the object - the variables always stay the same

Interfaces, like abstract classes, provide templates of behavior that other classes are expected to implement.

Java's interfaces are designed to solve dynamic method resolution at runtime.

Definition: An interface is a collection of method names, without actual definitions, that indicate that a class has a set of behaviors in addition to the behaviors the class gets from its superclass.

The major difference between interface and abstract is that an interface provides a means of encapsulating method protocols without forcing the user to subclass.

An example:
Sorting (CoreJava V1, Chapter 6). You want a general sorting routine that would work on many different kinds of Java objects, so you write an abstract class Sortable. Your choices:

Interfaces: More like uses than isa

public interface AudioClip { // start playing the clip. void play(); // Play the clip in a loop void loop(); // Stop the clip void stop(); }

Provides design - if one has an audioClip, what do I expect it to be able to do? What do I expect as behaviors?

Now, anytime I use an AudioClip, I know it has play(), loop(), and stop()

class MyClass implements AudioClip { // implicitly extends Object void play () { } void loop() { } void stop() { } }

An interface can be implemented in any number of classes, allowing each class to share the programming interface without having to be fully aware of each other's implementation. If two very disparate classes implement the same interface, they can both respond to the same method calls (as defined by the interface), although what each class does in response to those methods calls may be very different.

class MyOtherClass implements AudioClip { void play () { } void loop() { } void stop() { } }

Also, one can have multiple inheritence directly through the interface declaration:

public interface MyFirstInterface extends Interface1, Interface2 { ... // remember all methods will be public abstract // all variables will be public static final }

So classes that implement MyFirstInterface must implement the methods defined in both Interface1 and Interface2

If no extends is given for interfaces, they do not default to inheriting from Object. (why not?)

• like classes, but without any implementation
• multiple inheritance allowed (classes can share interface without sharing implementation)
• methods are implicitly abstract (public abstract)
• variables must be constants (public static final) (no ivs)
• direct ripoff from Objective C
• like classes, declared in source files - one interface to a file
• like classes, are compiled into .class files
• DIFFERENCE: interfaces cannot be instantiated

• className implements interfaceName(s)
• an interface or class can implement multiple interfaces
• classes must implement all methods defined in inherited interfaces
• classes automatically support all interfaces supported by their superclasses

public interface Storing { void freezeDry(OutputStream s); void reconstitute(InputStream s); }

class Image implements Storing { void freezeDry(OutputStream s) { // JPEG compress image and save } void reconstitute(InputStream s) { // retrieve JPEG image and uncompress // stores in an IV so doesn't return anything } }

class StorageManager { OutputStream out; void pickle(Storing obj) { // obj can be instantiated as image OR obj.freezeDry(out); } }

Storing obj = new Image();

if done this way, the variable obj is declared as the interface Storing, yet is assigned an instance of Image. This way, obj can be used to access the freezeDry method, and not any of the other aspects of the Image class.

Often a use of interfaces is to allow a callback: (The Java Handbook, page 139)

• you can declare variables as object references which use an interface as the type rather than a class.
• Any instance of any class which implements the declared interface may be stored by such a variable.
• If you want to call a method via one of these variables, the correct implementation will be called based on the actual instance.

• The method to be called is looked up dynamically at runtime, allowing classes to be created later than the code that calls methods on them.
• The calling code can dispatch through an interface without having to know anything about the callee.

A concrete example use: in my CSCI 311 java class we wanted to time methods using different structures and algorithms. Since there is no way to directly point to methods in Java (no method pointers, only call by name for methods), we needed to work around this.One way to set this up was to have the classes to be timed implement a Timer. Another was to have each class to be timed have the same name (and use polymorphism). (Ultimately works the same, but an interface makes it clean...and this idea seemed to make the classes not as "OO reusable")

interface Timed { public void tick(Timer t); }

class MyClassWithMethod implements Timed { .... Timer myTimer = new Timer(this); ... public void tick(Timer t){ ... // all the stuff that is the method that // we want to be run in the Timer } public void timeMe(){ myTimer.start(); // you probably want to do more in here } }

class Timer extends Thread { Timed owner; // the variable Timer(Timed t){ owner = t; } // the constructor makes the passed variable an IV // notice it does not have to say it is a MyClassWithMethod // this is the powerful point here. Since it implements // Timed, that is all it needs, so any class that // implements Timed can use this class ... public void run() { while (true) { sleep(interval); owner.tick(this); } } }