• Review:
  • Local classes allow for the inclusion of classes that are tightlty coupled to a black of code
  • Anonymous classes allow for the inclusion of classes that are only used once and, hence, needn't be named
• Lambda Expressions:
  • Provide a compact syntax for the equivalent of an anonymous class with only one method

• Formal Parameters:
  • A comma-separated list enclosed in parentheses (if there is more than one), with or without type declarations
• The Arrow Token:
  • ->
• The Body:
  • A single experssion or block statement

• A Single Expression:
  • The expression is evaluated and the result is returned
• A Block with a return Statement:
  • Since the return statement is not an expression, it must be within enclosing curly brackets (i.e., in a block)
• A Block without a return:
  • Is appropriate for void invocations

• Compact Versions of Anonymous Classes:
  • An anonymous class would work but seems needlessly verbose
• Method Passing:
  • You want to pass code as data (as in the command pattern and strategy pattern)

• Members in the Enclosing Class:
  • The local class can access all members
• Access to Local Variables:
  • The local class can access all local variables that are declared to be final or (since Java v8) are effectively final

javaexamples/nested/ComparatorExample.java (Fragment: lambda)

            Arrays.sort(data, (String a, String b) -> 
      {
        if (a == null) a = "";
        if (b == null) b = "";
    
        if      (a.length() > b.length()) return  1;
        else if (a.length() < b.length()) return -1;
        else                              return  0;
      }      
    );
        

javaexamples/nested/VectorMath.java

        /**
 * A partial implementation of a utility class for performing vector arithmetic.
 * 
 * @author  Prof. David Bernstein, James Madison University
 * @version 1.0
 */
public class VectorMath
{
  /**
   * The requirements of a Metric.
   */
  public interface Metric
  {
    /**
     * Calculate the distance between two vectors.
     * 
     * @param v  One vector
     * @param w  The other vector
     * @return   The distance between v and w
     */
    public abstract double distance(double[] v, double[] w);
  }    
  
  
  /**
   * Find the closest vector in a collection of destinations to the given
   * origin vector.
   * 
   * @param d The Metric to use to calculate the distance
   * @param origin The origin vector
   * @param destinations The set of destination vectors
   * @return A reference to the closes vector in the colelction of destinations
   */
  public static double[] closest(Metric d, double[] origin, double[]... destinations)
  {
    double   min = Double.POSITIVE_INFINITY;
    double[] argmin = null;
    
    for (double[] dest: destinations)
    {
      double temp = d.distance(origin, dest);
      if (temp < min)
      {
        min = temp;
        argmin = dest;
      }
    }
    
    return argmin;
  }
  
}
        

javaexamples/nested/VectorMathDriver.java (Fragment: rectilinear)

              double[] nearby = VectorMath.closest(
          // A lambda expression for the rectilinear metric
          (double[] p, double[] q) ->
          {
            double sum = 0.0;
            for (int i=0; i<p.length; i++)
            {
              sum += Math.abs(p[i] - q[i]);
            }
            return sum;
          }, 
          a, b, c);
        

javaexamples/nested/VectorMathDriver.java (Fragment: Euclidean)

              double[] nearby = VectorMath.closest(
          // A lambda expression for the Euclidean metric
          (double[] p, double[] q) ->
          {
            double sum = 0.0;
            for (int i=0; i<p.length; i++)
            {
              sum += Math.pow(p[i] - q[i], 2.0);
            }
            return Math.sqrt(sum);
          }, 
          a, b, c);
        

@Test
public void sqrt() {
 Throwable exception = assertThrows(IllegalArgumentException.class, 
   () -> {
           RealMath.sqrt(-1.0);
         });
        assertEquals("The result is not real", exception.getMessage());
}
  

  JButton close = new JButton("Close");

  // The most complete version
  close.addActionListener(
    (ActionEvent event) -> {f.dispose();}
  );
  

  JButton close = new JButton("Close");

  // Because the method is void it needn't be in a block
  close.addActionListener(
    (ActionEvent event) -> f.dispose() 
  );
  

  JButton close = new JButton("Close");

  // The type of the parameter can be omitted
  close.addActionListener(
    (event) -> f.dispose()
  );
  

  JButton close = new JButton("Close");

  // Because there is one parameter the parentheses can be omitted
  close.addActionListener(
    event -> f.dispose()
  );