Core Java

Interfaces, Lambda Expressions, and Inner Classes

Slide navigation: Forward with space bar, → arrow key, or PgDn. Backwards with ← or PgUp.

.jpg

Except where otherwise noted, this work is licensed under

Understand the concept of interfaces

The Interface Concept

Interface=set of requirements for classes.
Class can choose to conform to one or more interfaces.
Interface is not a class.
Service provider: “If your class conforms to a particular interface, then I'll perform the service.”
Example: Arrays.sort sorts an array if the element class conforms to the Comparable interface.

Interface definition:

public interface Comparable
{
   int compareTo(Object other); // automatically public
}

Conforming class must provide compareTo method.

Implementing an Interface

A class can choose to implement one or more interfaces:

public class Employee implements Comparable
{
   public int compareTo(Object otherObject)
   {
      Employee other = (Employee) otherObject;
      return Double.compare(salary, other.salary);
   }
   . . .
}

The compareTo method returns:
- A positive integer if otherObject should come before this object.
- Zero if the two are indistinguishable.
- A negative integer otherwise.

Can avoid the cast with the generic version of the Comparable interface:

class Employee implements Comparable<Employee>
{
   public int compareTo(Employee other)
   {
      return Double.compare(salary, other.salary);
   }
   . . .
}

Making Use of an Interface

A sorting algorithm keeps comparing elements and rearranges them if they are out of order:
```
if (a[i].compareTo(a[j]) > 0)
{
   // rearrange a[i] and a[j]
   . . .
}
```
How does the compiler know that the call a[i].compareTo(a[j]) is valid?
If a is declared to be Comparable[], then a[i] has a compareTo method:
```
public static void sort(Comparable[] a)
```

interfaces

Understand the properties of Java interfaces

Properties of Interfaces

Since an interface isn't a class, you can't instantiate it:
```
x = new Comparable(. . .); // Error
```
You can have variables of interface type:
```
Comparable x; // OK
```
The variable must refer to an object of a class that implements the interface:
```
x = new Employee(. . .); // OK provided Employee implements Comparable
```

Can make instanceOf check:

if (anObject instanceof Comparable) { . . . }

Properties of Interfaces

An interface can extend another:

public interface Moveable
{
   void move(double x, double y);
}

public interface Powered extends Moveable
{
   double milesPerGallon();
}

An interface can have fields:

public interface Moveable
{
   . . .
   double SPEED_LIMIT = 95; // automatically public static final
}

A class can implement multiple interfaces:

public class Employee implements Comparable, Moveable { ... }

Interfaces and Abstract Classes

Why not make Comparable into an abstract class?

abstract class Comparable // why not?
{
   public abstract int compareTo(Object other);
}

Then Employee would simply extend it:

class Employee extends Comparable // why not?
{
   public int compareTo(Object other) { . . . }
}

Problem: What if Employee already has a superclass?

class Employee extends Person, Comparable // Error

Java has no “multiple inheritance”.

Static Methods in Interfaces

Allowed since Java 8.
Originally disallowed since it wasn't in the spirit of interfaces as abstract specifications.
You can find many pairs of interface/companion class in the Java API: Collection/Collections, Path/Paths
Paths has a factory method get to make a Path object.

In Java 8, this would be better solved with a static method in the Path interface:

public interface Path
{
   public static Path get(String first, String... more)
   {
      return FileSystems.getDefault().getPath(first, more);
   }
   . . .
}

Work with default methods

Default Methods in Interfaces

Can supply a default implementation for any interface method:

public interface Comparable<T>
{
   default int compareTo(T other) { return 0; }
   // By default, all elements are the same
}

More compelling example—event handler:

public interface MouseListener
{
   default void mouseClicked(MouseEvent event) {}
   default void mousePressed(MouseEvent event) {}
   ...
}

A default method can call an abstract method:

public interface Collection
{
   int size(); // An abstract method
   default boolean isEmpty() { return size() == 0; }
   . . .
}

Interface Evolution

Consider the Collection interface that has been in the JDK for many years.
Suppose someone provided a class Bag implementing Collection.
Later, another method is added to Collection. (This actually happened with the stream method in JDK 8.)
If it's not a default method, then Bag no longer compiles—the change is not source compatible.
The same change is binary compatible—the Bag class still works, as long as nobody calls the new method. (Otherwise, an AbstractMethodError occurs.)
Making a new interface method a default method solves both problems.

Resolving Default Method Conflicts

What happens when the exact same method is defined as a default method in one interface and again as a method of a superclass or another interface?
Two simple rules:
- Interfaces clash. If an interface provides a default method and another interface provides the same one (default or not), you must resolve the conflict.
- Superclasses win. Concrete superclass methods mask default methods.

The “Interfaces Clash” Rule

Consider two interfaces:

interface Person {  default String getName() { return "John Q. Public"; }; }
interface Named { default String getName() { return getClass().getName() + "_" + hashCode(); } }

What happens if a class implements both?
You need to implement the getName method.

If you like, you can call one or the other interface method:

class Student implements Person, Named
{
   public String getName() { return Person.super.getName(); }
   . . .
}

Even if Named.getName is abstract, you must provide Student.getName.
If both methods are abstract, you can provide an implementation or declare the class abstract.

The “Superclasses Win” Rule

Assume that Person is a superclass and Named is an interface:
```
class Student extends Person implements Named { . . . }
```
Only the superclass method matters.
The default method Named.getName is ignored.
Ensures compatibility with Java 7: If you add a default method to an interface, it has no impact on existing code.

Java 9 News Flash - Private Interface Methods

.png

Interfaces can have concrete private and private static methods.
Any interface method is abstract, default, static, private, or private static
Private methods can only be called from default and static methods of the same interface.
Potentially useful for factoring out common code.

Become familiar with use cases for interfaces

Callbacks

Callback: Action that should happen when an event occurs.
- Example: Timer makes callback whenever a time interval has elapsed.

Give the timer an object of a class that implements this interface:

public interface ActionListener
{
   void actionPerformed(ActionEvent event);
}

The timer calls the actionPerformed method:

class TimePrinter implements ActionListener
{
   public void actionPerformed(ActionEvent event)
   {
      System.out.println("At the tone, the time is " + new Date());
      Toolkit.getDefaultToolkit().beep();
   }
}

Construct and install the object:

ActionListener listener = new TimePrinter();
Timer t = new Timer(10000, listener);
t.start();

timer

Comparators

You saw how Arrays.sort sorts an array of Comparable objects.
- What if you want to sort the objects in a different way?
- What if the objects belong to a class that doesn't implement Comparable?

A second version of Arrays.sort accepts a comparator:

public interface Comparator<T>
{
   int compare(T first, T second);
}

This comparator compares strings by length:

class LengthComparator implements Comparator<String>
{
   public int compare(String first, String second)
   {
      return first.length() - second.length();
   }
}

Pass an instance to Arrays.sort:

String[] friends = { "Peter", "Paul", "Mary" };
Arrays.sort(friends, new LengthComparator());

Cloning

.gif

Recall what happens when you make a copy of an object variable:

Employee original = new Employee("John Public", 50000);
Employee copy = original;
copy.raiseSalary(10); // oops--also changed original

Remedy: Call the clone method.
The Cloneable interface indicates that a class provides a safe clone method.

If Employee is cloneable, then you can call

Employee copy = original.clone();
copy.raiseSalary(10); // OK--original unchanged

Shallow Copies

Cloneable is an interface without methods:
```
public interface Cloneable {}
```
The clone method is a protected method of the Object class.
The method is protected because it is tricky to implement correctly.
Object.clone makes a “shallow” copy: a new object with the same fields.
That is bad if one of the fields is a reference to a mutable object:

Deep Copies

You must implement a deep copy and clone any mutable fields:

class Employee implements Cloneable
{
   . . .
   public Employee clone() throws CloneNotSupportedException
   {
      Employee cloned = (Employee) super.clone();
      cloned.hireDay = (Date) hireDay.clone();
      return cloned;
   }
}

You can catch the CloneNotSupportedException in a final clone method.
Less than 5% of the classes in the Java API are cloneable.

clone

Understand how lambda expressions work

Why Lambdas?

Lambda expression = Block of code that you can pass around so it can be executed later.
Reduces tedious boilerplate for callbacks.
When sorting strings by length, the compare method had to be called repeatedly to compute
```
first.length() - second.length()
```

Lambda expression:

(String first, String second) -> first.length() - second.length()

Much simpler than:

class LengthComparator implements Comparator<String>
{
   public int compare(String first, String second)
   {
      return first.length() - second.length();
   }
}

The Syntax of Lambda Expressions

Simplest form: (parameters) -> expression

If the code doesn't fit in a single expression, use { } and a return statement:

(String first, String second) ->
{
   if (first.length() < second.length()) return -1;
   else if (first.length() > second.length()) return 1;
   else return 0;
}

If there are no parameters, you still supply parentheses:
```
() -> Toolkit.getDefaultToolkit().beep(); 
```

If parameter types can be inferred, omit them:

Comparator<String> comp = (first, second) -> first.length() - second.length();

If there is exacty one parameter with inferred type, omit parentheses:

ActionListener listener = event -> Toolkit.getDefaultToolkit().beep();

Functional Interfaces

Functional interface = Interface with a single abstract method.
- Examples: ActionListener, Comparator

Lambda expression can be used whenever a functional interface value is expected:

Arrays.sort(words,
   (first, second) -> first.length() - second.length());

Timer t = new Timer(1000, event ->
   {
      System.out.println("At the tone, the time is " + new Date());
      Toolkit.getDefaultToolkit().beep();
   });

Conversion to a functional interface is the only thing that you can do with a lambda expression.

lambda

Generic Functional Interfaces

The java.util.function package defines generic functional interfaces:

public interface Predicate<T>
{
   boolean test(T t);
   . . .
}

public interface BiFunction<T, U, R>
{
   R apply(T t, U u);
}

ArrayList has a removeIf method that takes a predicate:
```
list.removeIf(e -> e == null);
```

Method References

Consider a lambda expression that calls a single method:

Timer t = new Timer(1000, event -> System.out.println(event));

You can use a method reference instead:

Timer t = new Timer(1000, System.out::println);

Another example:

Arrays.sort(words, String::compareToIgnoreCase)

Three cases:
- object::instanceMethod
- Class::staticMethod
- Class::instanceMethod

Constructor References

Person::new is a reference to a Person constructor.
- Same as s -> new Person(s)
- The compiler uses overloading resolution to pick the correct constructor.

Example—turn list of names into list of Person objects:

ArrayList<String> names = . . .;
Stream<Person> stream = names.stream().map(Person::new);
List<Person> people = stream.collect(Collectors.toList());

The map method turns a stream of strings into a stream of Person objects.
Constructor references also work for arrays:
- int[]::new is the same as the lambda expression n -> new int[n]
- Useful to overcome limitation of Java generics: Illegal to call new T[n]
- Turn stream to array of the correct type:
```
Person[] people = stream.toArray(Person[]::new);
```

Variable Scope

A lambda expression can access variables from the enclosing scope:

public static void repeatMessage(String text, int delay)
{
   ActionListener listener = event ->
   {
      System.out.println(text);
      Toolkit.getDefaultToolkit().beep();
   };
   new Timer(delay, listener).start();
}

Consider a call:

repeatMessage("Hello", 1000); // Prints Hello every 1,000 milliseconds

The text variable is not defined in the lambda expression.
It is gone when repeatMessage returns!
A lambda expression is a closure, containing:
1. A block of code
2. Parameters
3. Values for the free variables

Effectively Final Variables

A lambda variable can only capture a variable whose value is effectively final:

public static void countDown(int start, int delay)
{
   ActionListener listener = event ->
   {
      start--; // Error: Can't mutate captured variable
      System.out.println(start);
   };
   new Timer(delay, listener).start();
}

Also illegal if the variable changes outside the lambda expression:

public static void repeat(String text, int count)
{
   for (int i = 1; i <= count; i++)
   {
      ActionListener listener = event ->
         System.out.println(i + ": " + text); // Error: Cannot refer to changing i
      new Timer(1000, listener).start();
   }
}

Processing Lambda Expressions

Repeat an action n times:

repeat(10, () -> System.out.println("Hello, World!"));

Pick a functional interface for the second parameter:

public static void repeat(int n, Runnable action)
{
   for (int i = 0; i < n; i++) action.run();
}

To pass the count to the action, pick a functional interface from the java.util.function package:

public static void repeat(int n, IntConsumer action)
{
   for (int i = 0; i < n; i++) action.accept(i);
}

Called like this:

repeat(10, i -> System.out.println("Countdown: " + (9 - i)));

More about Comparators

Comparator interface has useful methods for creating and composing comparators.
The static method comparing makes a comparator from a key extractor function:
```
Arrays.sort(people, Comparator.comparing(Person::getName));
```
If the key is a primitive type, use comparingInt or comparingDouble to avoid boxing:
```
Arrays.sort(words, Comparator.comparingInt(String::length));
```

The default method thenComparing chains comparators:

Arrays.sort(people,
   Comparator.comparing(Person::getLastName)
      .thenComparing(Person::getFirstName));

Understand the inner workings of inner classes

Inner Classes

Inner class = Class that is defined inside another class.
Before lambda expressions, inner classes were commonly used for callbacks.
They are still useful for hiding implementation details.

Example:

public class TalkingClock
{
   private int interval;
   private boolean beep;
   public TalkingClock(int interval, boolean beep) { . . . }
   public void start() { . . . }

   public class TimePrinter implements ActionListener // an inner class
   {
      . . .
   }
}

A TalkingClock object does not have a TimePrinter inside.

Inner and Outer Classes

.gif

Inner class implementation:

public class TimePrinter implements ActionListener
{
   public void actionPerformed(ActionEvent event)
   {
      System.out.println("At the tone, the time is " + new Date());
      if (beep) Toolkit.getDefaultToolkit().beep();
   }
}

Which beep?
The beep field of the TalkingClock object that created this TimePrinter object.
The inner class object has a reference to the outer class object that created it.

innerClass

Inner Class Syntax

The reference to the outer class is OuterClass.this:
```
if (TalkingClock.this.beep) . . .
```
The name of a (non-private) inner class is OuterClass.InnerClass outside the outer class.

Any outer class object can construct an inner class object:

TalkingClock jabberer = . . .;
TalkingClock.TimePrinter listener = jabberer.new TimePrinter();

Local Inner Classes

We only needed the TimePrinter class in a single method.

Local inner class = class defined inside a method:

public void start()
{
   class TimePrinter implements ActionListener
   {
      public void actionPerformed(ActionEvent event)
      {
         System.out.println("At the tone, the time is " + new Date());
         if (beep) Toolkit.getDefaultToolkit().beep();
      }
   }
   ActionListener listener = new TimePrinter();
   Timer t = new Timer(interval, listener);
   t.start();
}

Local classes are never public, private, or protected.
Local classes can access effectively final variables from the enclosing scope:
```
public void start(int interval, boolean beep)
```

Anonymous Inner Classes

If a local class is only instantiated once, it can be anonymous:

public void start(int interval, boolean beep)
{
   ActionListener listener = new ActionListener()
   {
      public void actionPerformed(ActionEvent event)
      {
         System.out.println("At the tone, the time is " + new Date());
         if (beep) Toolkit.getDefaultToolkit().beep();
      }
   };
   Timer t = new Timer(interval, listener);
   t.start();
}

General syntax:

new SuperType(construction parameters)
{
   inner class methods and fields
}

If there is just one method, use a lambda expression.

anonymousInnerClass

Static Inner Classes

Static inner class = inner class without reference to creating object.
Useful for a private or scoped class that doesn't need to know the creating object.

Example:

class ArrayAlg
{
   public static class Pair
   {
      public double first;
      public double second;
   }
   . . .
   public static Pair minmax(double[] values)
   {
      . . .
      return new Pair(min, max); // no creating object
   }
}

Called as:

ArrayAlg.Pair p = ArrayAlg.minmax(data);

Core Java

Interfaces, Lambda Expressions, and Inner Classes

Understand the concept of interfaces

The Interface Concept

Implementing an Interface

Making Use of an Interface

interfaces

Understand the properties of Java interfaces

Properties of Interfaces

Properties of Interfaces

Interfaces and Abstract Classes

Static Methods in Interfaces

Work with default methods

Default Methods in Interfaces

Interface Evolution

Resolving Default Method Conflicts

The “Interfaces Clash” Rule

The “Superclasses Win” Rule

Java 9 News Flash - Private Interface Methods

Become familiar with use cases for interfaces

Callbacks

timer

Comparators

Cloning

Shallow Copies

Deep Copies

clone

Understand how lambda expressions work

Why Lambdas?

The Syntax of Lambda Expressions

Functional Interfaces

lambda

Generic Functional Interfaces

Method References

Constructor References

Variable Scope

Effectively Final Variables

Processing Lambda Expressions

More about Comparators

Understand the inner workings of inner classes

Inner Classes

Inner and Outer Classes

innerClass

Inner Class Syntax

Local Inner Classes

Anonymous Inner Classes

anonymousInnerClass

Static Inner Classes

staticInnerClass