Keep in mind that part of the Lambda/Streams Tutorial & References is still in draft version.

Default Methods

Interface Evolution

public interface Iterable<T> {

    public Iterator<T> iterator();

    public void forEach(Consumer<? super T> consumer);

}
 
 

With this modification, every implementing class does no longer compile because it lacks an implementation of the  forEach method.  The point of a default method is that it supplies the missing implementation so that the implementing classes need not be changed.  Using a default method the  Iterable interface looks like this:

public interface Iterable<T> {

    public Iterator<T> iterator();

    public  default void forEach(Consumer<? super T> consumer) {

        for (T t : this) {

            consumer.accept(t);

        }

    }

}
 
 

The obvious difference to a regular method in a class is the  default modifier.  Otherwise, the default method has an implementation pretty much like a regular method in a class. 

In addition to the  default modifier there is another notable difference between regular methods in classes and default methods in interfaces: methods in classes can access and modify not only their method arguments but also the fields of their class.  A default method in contrast can only use its arguments because interfaces do not have state.  (The fields that you can define in an interface are not really state; they are  static final fields, i.e. symbolic names for compile-time constant values, which the compiler eliminates during compilation.)  All that the implementation of a default method can build on are its own method arguments and the other methods declared in the interface.

Take a look at the default implementation of the  forEach method above.  To illustrates the principle we slightly rewrite it; we replace the for-each loop by explicit use of an iterator. Rewritten the  Iterable interface looks like this.

public interface Iterable<T> {

    public Iterator<T>  iterator ();

    public default void forEach(Consumer<? super T>  consumer ) {

        Iterator<T> iter =  iterator ();

        while (iter.hasNext()) {

             consumer .accept(iter.next());

        }

    }

}
 
 

The  forEach method uses

• its  Consumer argument, which represents the functionality that is to be applied to each element in the collection, and

• the not yet implemented, abstract  iterator method that the  Iterable interface declares.
 
 

Essentially, default methods are combinations of the other methods declared in the same interface.  multiple inheritance   ambiguous inheritance

Multiple Inheritance and Ambiguities

Since classes in Java can implement multiple interfaces and each interface can have default methods, the inherited methods may be in conflict with each other if they have matching signatures.  For instance, a class  C might inherit a method  foo from both an interface  I1 and an interface  I2 .  It raises the question: which method does class  C inherit?
 
 

Diagram: Ambiguous Multiple Inheritance - Needs explicit resolution.

In such a situation the compiler cannot resolve the ambiguity and reports an error.  In order to enable the programmer to resolve the ambiguity there is syntax for explicitly stating which method class  C is supposed to inherit.  A resolution could look like this:

class C implements I1, I2 {

   public void foo() {  I1.super .foo(); }

}
 
 

This is just one example of a conceivable ambiguous inheritance of default methods.  There are numerous further examples. In some situation the compiler can resolve the situation because the language has a resolution rule for that situation.  In those few cases where the compiler reports an error (like in the example above) there is syntax for explicit resolution.  If you are interested in a more elaborate discussion of multiple inheritance in Java and/or details regarding the resolution of ambiguous multiple inheritance of default methods, please consult the section on "Default Methods" in the Lambda Reference document.

CONTENT   NEXT     INDEX