学习目标
- 接口
- 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)。将一个方法实现为一个默认方法就可以解决这个问题。
(六)解决默认方法冲突
在一个接口中将一个方法定义为默认方法,然后在超类或另一个接口中定义同样的方法,处理规则如下:
- 超类优先。
- 接口冲突。如果一个接口提供了一个默认方法,另一个接口提供了相同的方法,必须覆盖这个方法来解决冲突。
如两个接口都实现了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),同时克隆所有子对象。
对于一个类,需要确定:
- 默认的clone方法是否满足需求
- 是否可以在可变的子对象上调用clone来修补默认的clone方法
- 是否不该使用clone
实际上第3个选项是默认选项。如果选择第1项或第2项,类必须:
- 实现Cloneable接口
- 重新定义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:异常、断言和日志