Java从零开始系列04：接口、lambda表达式与内部类

学习目标

• 接口
• lambda表达式
• 内部类

一、接口

（一）接口的概念

接口（interface）用来描述类应该做什么，而不指定它们具体应该如何做一个类可以实现（implement）多个接口。

接口不是类，而是对希望符合这个接口的类的一组需求。如，Arrays类中的sort方法承若可以对对象数组进行排序，但要求满足下面这个条件：对象所属的类必须实现Comparable接口：

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

这说明，任何实现 Comparable 接口的类都需要包含 compareTo 方法，这个方法有一个Object参数，并且返回一个整数。

Java5 中，Comparable 接口已提升为一个泛型类型。

public interface Comparable<T>
{
	int compareTo(T other);	// parameter has type T
}

接口中所有方法都自动是public方法，无需提供关键字public。

接口中绝不会包含实例字段。可以将接口看成是没有实例字段的抽象类。

现在，假设希望使用Arrays类的sort方法对Employee对象数组进行排序，Employee类就必须实现接口。为了让类实现一个接口，通常需要以下两个步骤：

• 将类声明为实现给定的接口
• 对接口中所有方法提供定义

要将类声明为实现某个接口，需要提供关键字implements：

class Employee implements Comparable

在实现接口时，必须把方法声明为public，以下是compareTo方法的具体实现：

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

也可以为泛型Comparable接口提供一个类型函数：

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

使用接口的主要原因是Java程序设计语言是一种强类型（strongly typed）语言。在调用方法时，编译器要检查这个方法确实存在。

下面给出一个对Employee实例数组进行排序的完整代码：

package interfaces;

import java.util.*;

/**
 * This program demonstrates the use of the Comparable interface.
 * @version 1.30 2004-02-27
 * @author Cay Horstmann
 */
public class EmployeeSortTest
{
   public static void main(String[] args)
   {
      var staff = new Employee[3];

      staff[0] = new Employee("Harry Hacker", 35000);
      staff[1] = new Employee("Carl Cracker", 75000);
      staff[2] = new Employee("Tony Tester", 38000);

      Arrays.sort(staff);

      // print out information about all Employee objects
      for (Employee e : staff)
         System.out.println("name=" + e.getName() + ",salary=" + e.getSalary());
   }
}

package interfaces;

public class Employee implements Comparable<Employee>
{
   private String name;
   private double salary;

   public Employee(String name, double salary)
   {
      this.name = name;
      this.salary = salary;
   }

   public String getName()
   {
      return name;
   }

   public double getSalary()
   {
      return salary;
   }

   public void raiseSalary(double byPercent)
   {
      double raise = salary * byPercent / 100;
      salary += raise;
   }

   /**
    * Compares employees by salary
    * @param other another Employee object
    * @return a negative value if this employee has a lower salary than
    * otherObject, 0 if the salaries are the same, a positive value otherwise
    */
   public int compareTo(Employee other)
   {
      return Double.compare(salary, other.salary);
   }
}

（二）接口的属性

接口不是类。不能使用new运算符实例化一个接口；但可以声明接口的变量：

Comparable x;

接口变量必须引用实现了这个接口的类对象：

x= new Employee(...);

可以使用instanceof检查一个对象是否实现了某个特定的接口：

if (anObject instanceof Comparable) {...}

与建立类的继承层次一样，也可以扩展接口。这里允许有多条接口链，从通用性较高的接口扩展到专用性较高的接口。假设，有一个名为Moveable的接口：

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

可以假设一个名为Powered的接口扩展了以上的接口，接口中可以含有常量：

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

每个类只能有一个超类，但可以有多个接口：

c;ass Employee implements Cloneable, Comparable

（三）接口与抽象类

使用接口而不是用抽象类的主要原因是每个类只能扩展一个类。有些语言（如C++）允许一个类有多个超类，称为多重继承（multiple inheritance），但Java不允许这样做。

使用接口可以提供多重继承的大多数好处，还可以避免多重继承的复杂性和低效性。

（四）静态和私有方法

在Java8中，允许在接口中增加静态方法。只是这有违将接口作为抽象规范的初衷。

通常的做法都是将静态方法放到伴随类中。在实现接口时，没有理由再为实用工具再提供一个伴随类。
在Java9中，接口中的方法可以是private。这种方法只能作为接口中其他方法的辅助方法。

（五）默认方法

可以为接口方法提供一个默认实现。必须用default修饰符标记这样一个方法：

public interface Comparable<T>
{
	default int compareTo(T other) {...}
}

默认接口可以调用其他方法。

默认方法的一个重要用法是“接口演化”（interface evolution）。为一个接口增加一个新的方法，之前提供的类将不能编译，因为它没有实现这个新方法。为接口增加一个非默认方法不能保证“源代码兼容”（source compatible）。将一个方法实现为一个默认方法就可以解决这个问题。

（六）解决默认方法冲突

在一个接口中将一个方法定义为默认方法，然后在超类或另一个接口中定义同样的方法，处理规则如下：

1. 超类优先。
2. 接口冲突。如果一个接口提供了一个默认方法，另一个接口提供了相同的方法，必须覆盖这个方法来解决冲突。

如两个接口都实现了getName方法：

interface Person
{
	default String getName()	{...}
}

interface Named
{
	default String getName()	{...}
}

则需要在类中添加一个getName方法：

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

若一个类扩展了一个超类，同时实现了一个接口，并从超类和接口继承了相同的方法。如：

class Student extends Person implements Named {...}

只会考虑超类方法，所有接口的默认方法都会被忽略。即“类优先”规则。

（七）接口与回调

回调（callback）是一种常见的程序设计模式。可以指定某个特定事件发生时应该采取的动作。

以下程序展示了定时器和动作监听器的具体使用。定时器启动后，程序将弹出一个消息对话框，并等待用户点击Ok按钮来终止程序的执行。在程序等待用户操作的同时，每隔1秒显示一次当前时间。

package timer;

/**
   @version 1.02 2017-12-14
   @author Cay Horstmann
*/

import java.awt.*;
import java.awt.event.*;
import java.time.*;
import javax.swing.*;

public class TimerTest
{  
   public static void main(String[] args)
   {  
      var listener = new TimePrinter();

      // construct a timer that calls the listener
      // once every second
      var timer = new Timer(1000, listener);
      timer.start();

      // keep program running until the user selects "OK"
      JOptionPane.showMessageDialog(null, "Quit program?");
      System.exit(0);
   }
}

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

（八）对象克隆

Cloneable接口指示一个类提供了一个安全的clone方法。如果希望copy一个新对象，其初始状态与original相同，但之后它们会各有不同的状态，就可以使用clone：

var original = new Employee(...);
Employee copy = original.clone();
copy.raiseSalary(10);

clone方法是一个protected方法，只有Employee类可以克隆Employee对象。

默认的克隆操作是“浅拷贝”，并没有克隆对象中引用的其他对象。一般适用于原对象和浅克隆对象共享的子对象是不可变的情况。如果子对象可变，则必须重新定义clone方法来建立一个深拷贝（deep copy），同时克隆所有子对象。

对于一个类，需要确定：

1. 默认的clone方法是否满足需求
2. 是否可以在可变的子对象上调用clone来修补默认的clone方法
3. 是否不该使用clone

实际上第3个选项是默认选项。如果选择第1项或第2项，类必须：

1. 实现Cloneable接口
2. 重新定义clone方法，并指定public访问修饰符

即使clone的默认（浅拷贝）实现能够满足要求，还是需要实现Cloneable接口，将clone定义为public，再调用super.clone()。

class Employee implements Cloneable
{
	public Employee clone() throws CloneNotSupportedException
	{
		// call Object.clone()`在这里插入代码片`
		Employee cloned = (Employee) super.clone();

		// clone mutable fields
		cloned.hireDay = (Date) hireDay.clone();

		return cloned;
	}
	...
}

必须当心子类的克隆。

下面是克隆Employee类的一个实例，然后调用两个更改器方法，用于改变字段的值，这两个更改器方法不会影响原来的对象，因此clone定义为建立一个深拷贝。

package clone;

/**
 * This program demonstrates cloning.
 * @version 1.11 2018-03-16
 * @author Cay Horstmann
 */
public class CloneTest
{
   public static void main(String[] args) throws CloneNotSupportedException
   {
      var original = new Employee("John Q. Public", 50000);
      original.setHireDay(2000, 1, 1);
      Employee copy = original.clone();
      copy.raiseSalary(10);
      copy.setHireDay(2002, 12, 31);
      System.out.println("original=" + original);
      System.out.println("copy=" + copy);
   }
}

package clone;

import java.util.Date;
import java.util.GregorianCalendar;

public class Employee implements Cloneable
{
   private String name;
   private double salary;
   private Date hireDay;

   public Employee(String name, double salary)
   {
      this.name = name;
      this.salary = salary;
      hireDay = new Date();
   }

   public Employee clone() throws CloneNotSupportedException
   {
      // call Object.clone()
      Employee cloned = (Employee) super.clone();

      // clone mutable fields
      cloned.hireDay = (Date) hireDay.clone();

      return cloned;
   }

   /**
    * Set the hire day to a given date. 
    * @param year the year of the hire day
    * @param month the month of the hire day
    * @param day the day of the hire day
    */
   public void setHireDay(int year, int month, int day)
   {
      Date newHireDay = new GregorianCalendar(year, month - 1, day).getTime();
      
      // example of instance field mutation
      hireDay.setTime(newHireDay.getTime());
   }

   public void raiseSalary(double byPercent)
   {
      double raise = salary * byPercent / 100;
      salary += raise;
   }

   public String toString()
   {
      return "Employee[name=" + name + ",salary=" + salary + ",hireDay=" + hireDay + "]";
   }
}

二、lambda表达式

（一）lambda表达式的使用

lambda表达式是一个可传递的代码块，可以在以后执行一次或多次。

lanbda表达式就是一个代码块，以及必须传入代码的变量规范：

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

如果代码要完成的计算无法放在一个表达式中，可以放在{}中：

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

即使lambda表达式没有参数，仍然需要提供空括号：

() -> {...}

如果可以推导出一个lambda表达式的参数类型，就可以忽略其类型

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

如果方法只有一个参数，而且这个参数类型可以推导出，甚至可以省略小括号。

无需指定lambda表达式的返回类型。其返回类型总会由上下文推导出。

下面程序展示了如何对一个比较器和一个动作监听器使用lambda表达式：

package lambda;

import java.util.*;

import javax.swing.*;
import javax.swing.Timer;

/**
 * This program demonstrates the use of lambda expressions.
 * @version 1.0 2015-05-12
 * @author Cay Horstmann
 */
public class LambdaTest
{
   public static void main(String[] args)
   {
      var planets = new String[] { "Mercury", "Venus", "Earth", "Mars", 
         "Jupiter", "Saturn", "Uranus", "Neptune" };
      System.out.println(Arrays.toString(planets));
      System.out.println("Sorted in dictionary order:");
      Arrays.sort(planets);
      System.out.println(Arrays.toString(planets));
      System.out.println("Sorted by length:");
      Arrays.sort(planets, (first, second) -> first.length() - second.length());
      System.out.println(Arrays.toString(planets));
            
      var timer = new Timer(1000, event ->
         System.out.println("The time is " + new Date()));
      timer.start();   
         
      // keep program running until user selects "OK"
      JOptionPane.showMessageDialog(null, "Quit program?");
      System.exit(0);         
   }
}

（二）函数式接口

lambda表达式与接口是兼容的，对于只有一个抽象方法的接口，需要这种接口的对象时，就可以提供一个lambda表达式。这种接口称为函数式接口（functional interface）。

下面考虑Array.sort方法，它的第二个参数需要一个Comparator实例，Comparator是只有一个方法的接口，可以提供一个lambda表达式：

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

实际上，lambda表达式也只是转换函数式接口。

（三）方法引用

有时，lambda表达式也设计了一个方法。例如，希望只要出现一个定时器事件就打印这个事件对象：

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

如果直接把println方法传递到Timer构造器就更好了：

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

表达式 System.out:: println 是一个方法引用（method reference），它指示编译器生成一个函数式接口的实例，覆盖这个接口的抽象方法来调用给定的方法。

用::运算符分割方法名与对象或类名。主要有3种情况：

• object::instanceMethod
• Class::instanceMethod
• Class::staticMethod

在第1种情况下，方法引用等价于向方法传递参数的lambda表达式。如：System.out::println等价于x->System.out.println(x)
在第2种情况下，第1个参数会成为方法的隐式参数。如：String::compareToIgnoreCase等价于(x,y)->x.compareToIgnoreCase(y)
在第3种情况下，所有参数都传递到静态方法。如：Math::pow等价于(x,y)->Math.pow(x,y)

只有当lambda表达式的体只调用一个方法而不做其他操作时，才能把lambda表达式重写为方法引用。

可以在方法引用中使用this参数。例如，this::equals等同于x->this.equals(x)。使用super也是合法的。

（四）构造器引用

Java有一个限制，无法构造泛型类型的数组。流库利用构造器引用解决这个问题。可以把Person[]::new传入toArray方法。

Person[] people = stream.toArray(Person[]::new);

（五）变量作用域

lambda表达式可以捕获外围作用域中变量的值，但只能引用值不会改变的变量。

lambda表达式中捕获的变量必须实际上是事实最终变量（effectively final）。这个变量初始化之后就不会再为它赋新值。

lambda表达式的体与嵌套块有相同的作用域。不能声明同名局部变量。

在一个lambda表达式中使用this关键字时，是指创建这个lambda表达式的方法的this参数。

（六）处理ambda表达式

lambda表达式的重点是延迟执行（deferred execution），希望以后执行主要出于以下原因：

• 在一个单独的线程中运行代码
• 多次运行代码
• 在算法的适当位置运行代码
• 发生某种情况时运行代码
• 只在必要时才运行代码

假设要重复一个动作n次，将这个动作和重复次数传递到一个repeat方法：

repeat(10, () -> System.out.println(“Hello world!”));

要接受这个lambda表达式，需要选择或提供一个函数式接口。在这里，我们可以选择Runnable接口：

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

需要说明，调用action.run()时会执行这个lambda表达式的主体。

现在希望告诉这个动作出现在哪一次迭代中。为此，需要选择一个合适的函数式接口，其中要包含一个方法。如下：

public interface IntConsumer
{
	void accept(int value);
}

下面给出repeat的改进版本

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

三、内部类

内部类（inner class）是定义在另一个类。使用内部类主要有两个原因：

• 内部类可以对同一个包中的其他类隐藏
• 内部类方法可以访问定义这个类的作用域中的数据，包括原本的私有数据

（一）使用内部类访问对象状态

内部类的语法相当复杂。这里以重构TimerTest为例，抽象出一个TalkingClock类。构造 一个语音的时钟需要提供两个参数：发出通知的间隔和开关铃声的标志：

public class TalkingClock
{
	private int interval;
	private boolean beep;

	public Talking(int interval, boolean beep)	{…}

	public void start()	{…}

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

需要注意，这里TimePrinter类位于TalkingClock类内部，但并不意味每个TalkingClock都有一个TimePrinter实例字段。TimePrinter对象是由TalingClock类的方法构造的。

下面是TimePrinter的具体实现：

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

beep指示TalkingClock对象中创建这个TimePrinter的字段。一个内部类方法可以访问自身的数据字段，也可以访问创建它的外围类对象的数据字段。

为此，内部类的对象总有一个隐式引用，只想创建它的外部对象。这个引用在内部类的定义中是不可见的。

外围类的引用在构造器中设置。编译器会修改所有的内部类构造器，添加一个对应外围类引用的参数。本例会自动生成一个构造器：

public TimePrinter(TalkingClock clock)
{
	outer = clock;	// 注意outer代指外围类对象的引用，实际不存在这个关键字
}

在start方法中构造一个TimePrinter对象后，编译器就会将当前语言时钟的this引用传递给这个构造器：

var listener = new TimePrinter(this);	// parameter automatically added

注：只有内部类可以是私有的

（二）内部类的特殊语法规则

表达式OuterClass.this表示外围类引用。如：

public void actionPerformed(ActionEvent event)
{
	…
	if (TalkingClock.this.beep)	Toolkit.getDefaultToolkit().beep();
}

反过来可以使用以下语法更明确地编写内部类对象的构造器：
outerObject.new InnerClass(construction parameters)
例如：

ActionListener listener = this.new TimePrinter();

可以通过显示地命名将外围类引用设置为其他对象。如：

var jabberer = new TalkingClock(1000, true);
TalkingClock.TimePrinter listener = javverer.new TimePrinter();

在外围类的作用域外，可以通过OuterClass.InnerClass引用内部类。

内部类声明的所有静态字段都必须为final。且不能有static方法。

（三）局部内部类

声明局部类时不能有访问说明符（public和private）。局部类的作用被限定在这个局部类的块中。

局部类有一个很大的优势，它可以对外部世界完全隐藏。

（四）由外部方法访问变量

局部类不仅能够访问外部类的字段，还可以访问局部变量。这些局部变量必须是事实最终变量（effectively final）。

（五）匿名内部类

使用局部内部类时，如果只想创建这个类的一个对象，甚至不需要命名，这样的类被称为匿名内部类（anonymous inner class）。

（六）静态内部类

有时，使用内部类只是为了把一个类隐藏在另一个类的内部。并不需要内部类有外部类对象的引用。可以讲内部类声明为static。

---

参考资料：

狂神说Java
Java核心技术 卷I（第11版）

---

上一章：Java从零开始系列03：继承
下一章：Java从零开始系列05:异常、断言和日志