读后笔记 -- Java核心技术（第11版 卷I ） Chapter6 接口、lambda 表达式与内部类
6.1 接口
6.1.1. 接口
不是类，而是对类的一组需求描述，这些类要遵从接口描述的同一格式定义。
接口与类的区别： 接口中默认的方法是 public abstract，所以不写的都是这个类型；
不能用于实例化对象； 没有构造方法； 所有的方法必须是抽象方法，Java 8 之后 接口中可以使用 default 关键字修饰的非抽象方法； 不能包含成员变量，除了 static 和 final 变量； 不是被类继承了，而是要被类实现； 支持多继承； ** 提供 实例字段 和 方法实现 的任务，由实现接口的那个类 来完成。
类实现一个接口，需要两步：
- 1）将类声明为实现给定的接口；
- 2）对接口中的所有方法进行定义；
public interface Comparable<T> { // since Java 5，提供泛型类型 int compareTo(T other); // 接口中的所有方法都是 public } public class Employee implements Comparable<Employee> { // 接口实现，Comparable 的 CompareTo()接受任意的 Object，上面接口有泛型类型支持的 Comparable 版本，可直接传递 Employee 类型，不用进行类型转换 @Override public int compareTo(Employee other) { // 接口方法的实现 return Double.compare(salary, other.salary); // 浮动数比较 Double.compare()，整数比较 Integer.compare() } ... }
知识点： Arrays.sort(Object[] a)； // 由于历史原因，API 里面的 sort 接受的是 Object[] 数组，然后再强制转换为 Comparable。理想情况应该是 public static void sort(Comparable[] a)
如果要对数组 a 中的元素排序，要求：数组中的元素必须属于实现了 Comparable 接口的类，并且元素间可比。
6.1.2. 接口的属性
// 1）可声明接口的变量，但必须引用实现了接口的类对象； Comparable x; // OK，声明接口变量 x = new Employee(...); // OK，Employee类 实现了 Comparable 接口（上面6.1.1的例子中），所以 x 可以引用 Employee 的类对象
// 另一个实际使用的例子，如:
List<String> list = new ArrayList(); // 可声明 List 接口的变量 list，但必须引用实现了该接口的类 ArrayList 的对象（通过new）
list.add("Amy"); // 2）可使用 instanceof 检查一个对象是否实现了特定的接口（类似于类）； if (anObject instanceof Comparable) {...} // 3) 接口可以通过 extends 再扩展；
public interface Moveable { ...; }
public interface Powered extends Moveable { ...; } // 4）接口不能包含 实例字段 或 静态方法，但可包含 常量； public interface Powered extends Moveable { double milesPerGallon(); // 方法自动标记为 public （一般不写） double SPEED_LIMIT = 95; // 自动标记为 public static final constant （一般不写） }
// 5）一个类：仅有一个超类，但可实现 多个接口 class Manager extends Employee implements Cloneable, Comparable { ...； }
6.1.3. 接口与抽象类
接口中包含的几种方法：
- 1) abstract => 在实现类中被覆盖
- 2-3) default, static (from java 8)
- 4-5) private, private static (from Java 9) => 目的：用于抽取这个接口中的公共代码
Q: 为什么不使用抽象类，而采用接口？
A: 每个类只能扩展一个类（如抽象类），但是可以引用 多个接口。如果将 Comparable 定义为抽象类，那么 Manager 就没办法同时扩展 Employee 类和 Comparable 类 ----- 4.1 Java 抽象类 ----- public abstract class Employee { ... } // 详细描述参看 5.1.9 https://www.cnblogs.com/bruce-he/p/15738254.html ----- 4.2 Java 抽象方法 ----- public abstract class Employee { ... public abstract double computePay(); ... }
如果你想设计这样一个类，该类包含一个特别的成员方法，该方法的具体实现由它的子类确定，那么你可以在父类中声明该方法为抽象方法。 abstract 关键字同样可以用来声明抽象方法，抽象方法只包含一个方法名，而没有方法体。 声明抽象方法会造成以下两个结果： 1）如果一个类包含抽象方法，那么该类必须是抽象类; 2）任何子类必须重写父类的抽象方法，或者声明自身为抽象类。最终，必须有子类实现该抽象方法，否则，从最初的父类到最终的子类都不能用来实例化对象。
更多详情参考：https://www.runoob.com/java/java-abstraction.html
6.1.4. 静态方法、私有方法
Java 8，接口有 静态 static 方法；通常将静态方法放在伴随类中，如 Collection/Collections、Path/Paths；
Java 9，接口有 私有 private 方法（可以是 静态方法 或 实例方法），只能在接口本身的方法中使用，故作为接口中其他方法的辅助方法；
public interface Path { // Since Java 11
public static Path of(URI uri) { ... } public static Path of(String first, String... more) { return FileSystems.getDefualt().getPath(first, more); } ... }
6.1.5. 默认方法 default
默认方法 : 接口可以有实现方法，而且不需要实现类去实现其方法。 Q：为什么要有这个特性？ A：之前的接口是个双刃剑，好处是面向抽象而不是面向具体编程，缺陷是，当需要修改接口时候，需要修改全部实现该接口的类，目前的 java 8 之前的集合框架没有 foreach 方法，通常能想到的解决办法是在 JDK 里给相关的接口添加新的方法及实现。
然而，对于已经发布的版本，是没法在给接口添加新方法的同时不影响已有的实现。所以引进的默认方法。他们的目的是为了解决接口的修改与现有的实现不兼容的问题。
白话解释：新的 SDK 接口中有增加一些方法，因为类要扩展接口，必须实现这些接口的方法，这就导致之前的类代码要重新写。一个办法就是，让接口中的新增方法变成 default 方法，且已经实现，那么以前类的代码就不用重新修改了。
更多参考：https://www.runoob.com/java/java8-default-methods.html
// A default method can call an abstract method: public interface Collection { int size(); // an abstract method default bolean isEmpty() { return size() == 0; } // call abstract method size() ... }
【例如 Collection 接口，后来 有人写了一个 Bag 方法实现 Colleciton 接口。 然后，在 JDK 8 中 Collection 接口增加了一个 Stream 方法，如果将其设置为 default 方法，就可以解决 Bag 方法冲突的问题 】
6.1.6. 解决默认方法冲突
冲突场景：如果先在一个接口中将一个方法定义为默认方法， 然后又在超类或另一个接口中定义了同样的方法
解决冲突的规则：
- 1）超类优先（超类+接口）。如果超类提供了一个具体方法，同名而且有相同参数类型的默认方法会被忽略；
- 2）接口冲突（>=2 接口）。如果一个超接口提供了一个默认方法，另一个接口提供了一个同名而且参数类型（不论是否是默认参数）相同的方法， 必须 覆盖这个方法 或 指定某接口的方法 来解决冲突；
// 1. 场景：实现两个接口的 默认方法冲突。 两种解决方法： public interface Vehicle { default void print() { System.out.println("我是一辆车!"); } } public interface FourWheeler { default void print(){ System.out.println("我是一辆四轮车!"); } } // 解决方案一：创建自己的默认方法，来覆盖重写接口的默认方法： public class Car implements Vehicle, FourWheeler { default void print(){ System.out.println("我是一辆四轮汽车!"); } } // 解决方案二： 使用 super 来调用指定接口的默认方法 public class Car implements Vehicle, FourWheeler { public void print(){ Vehicle.super.print(); } }
// 1. 接口冲突：两个接口都定义相同的方法，类 Student 要同时实现 Person 和 Named 接口 // 场景 1.1： 如果有一个是默认方法，或两个都是默认方法。 // 解决办法：实现类必须做出决定，具体调用哪个接口的方法，“Interface.super.method();” interface Person { default String getName() { return "John Q. Public"; } } interface Named { default String getName() { return getClass().getName() + "_" + hashCode(); } } class Student implements Person, Named { public String getName() { return Person.super.getName(); } // 指定调用的具体接口的 默认方法 ... } // 场景 1.2：如果 两个方法都是抽象方法， // 另外一个解决办法：实现 方法 或 将类声明为 abstract
// 2. 类优先： Student 类继承 Person 类 和 Named 接口，两者提供一样的 getName 方法 ----- 超类 Person.java ------ public class Person { private String name; public Person(String name) { this.name = name; } public String getName() { return name; } } ----- 接口 Named.java ------ public interface Named { default String getName() { return getClass().getName() + "_" + hashCode(); } } ----- 子类 Student.java ------ public class Student extends Person implements Named { public Student(String name) { super(name); } } ----- 测试类 ------ Student harry = new Student("Harry Porter"); System.out.println(harry.getName()); // 输出： "Harry Porter"， 超类 Person 有 getName()，接口 Named 有 getName()，当方法冲突时，使用类 Person 的方法
6.1.7. 接口与回调
回调 Callbacks：常见的程序设计模式，可以指定某个特定事件发生时应该采取的动作。如 Timer 类
public class TimerTest { public static void main(String[] args) { ActionListener listener = new TimerPrinter(); // 定义一个接口的变量 listener，必须引用实现了该接口的类的对象； // construct a timer that calls the listener Timer t = new Timer(10000, listener); t.start(); JOptionPane.showMessageDialog(null, "Quit program?"); System.exit(0); } } class TimerPrinter implements ActionListener { @Override public void actionPerformed(ActionEvent e) { System.out.println("At the tone, the time is " + new Date()); Toolkit.getDefaultToolkit().beep(); } }
6.1.8. Comparator 接口
// 使用 Comparator 接口的 Compare 方法，可以自定义排序。有别于 Comparable 接口的 Comparable 排序
public class ComparatorTest { public static void main(String[] args) { String[] friends = {"Peter", "Paul", "May", "Albert"}; Arrays.sort(friends); System.out.println(Arrays.toString(friends)); // 按照 字典顺序 排序，[Albert, May, Paul, Peter] Arrays.sort(friends, new LengthComparator()); System.out.println(Arrays.toString(friends)); // 按照 字符串长度 排序，[May, Paul, Peter, Albert] } } class LengthComparator implements Comparator<String> { @Override public int compare(String o1, String o2) { return o1.length() - o2.length(); } }
6.1.9. 对象克隆
Employee original = new Employee("John Public", 50000); // 1) make a copy, original also changed Employee copy = original; copy.raiseSalary(10); // original also changed // 2) clone, then original is not changed Employee copy = original.clone(); copy.raiseSalary(10); // original is not changed
对于每一个类，需要确定的一个思路是：
- 1）默认的 clone 方法是否满足要求；
- 2）是否可以在可变的子对象上调用 clone 来修补默认的 clone 方法；
- 3）是否不该使用 clone ---- （默认，一般不使用）；
如果选择 1）或 2），则该类必须：
- 1）实现 Cloneable 接口；
- 2）重新定义 clone 方法，并指定为 public；
！！! Object.clone 仅提供 浅copy，其特点是： 1. 如果 原对象 和 浅clone 共享的子对象是不可变的（如 String 类）；或者 子对象 一直包含不变的常量，没有更改器改变它，也没有方法会生成它的引用，那么这种共享是安全的； 2. 如果 子对象 是可变的，那么 任意改变一个，两者都会改变，这就不适用于 浅copy 了； => 需要定义一个 deep copy 另外，Object.clone 方法是 protected，子类只能调用该方法来 clone 自己的对象，必须将 clone() 重新定义为 public，才能允许所有的方法来克隆对象。 深copy （即使 浅copy 满足要求，下面的第一步还是需要实现）： 1). 浅 copy： a) 实现 Cloneable 接口；b） 重新定义 clone 方法为 public； c）调用 super.clone()； 2). + clone 对象中可变的实例字段；
注意，Cloneable 接口是标记接口，其内部没有任何方法，唯一用途就是允许使用 instanceof 进行类型查询。
详细的描述：https://www.cnblogs.com/bruce-he/p/17271648.html
// 实现 Cloneable 接口 class Employee implements Cloneable { ... public Employee clone() throws CloneNotSupportedException { // 1) 重新定义 Clone()； 2）方法声明为 public // 3）调用 super.clone()方法，其调用 Object.clone()，并复制所有字段。Object.clone() 检查方法是否可以 clone，并是否实现了 Cloneable 接口，否则 throw 一个异常 Employee cloned = (Employee) super.clone(); // 将返回的 Object 对象转回成实际类型对象 // 4) clone 对象中可变的实例字段 (Employee 类提供了一个可设置的 setHireDay 方法)，并 加入到 cloned 对象 cloned.hireDay = (Date) hireDay.clone(); return cloned; } }
所有的数组类型 都有一个 public 的 clone 方法，所以可以直接调用，不需要重新定义
int[] luckyNumbers = {2, 3, 5, 7, 11, 13}; int[] cloned = luckyNumbers.clone(); cloned[5] = 12; // doesn't change luckyNumbers[5] // [2, 3, 5, 7, 11, 13] System.out.println(Arrays.toString(luckyNumbers)); // [2, 3, 5, 7, 11, 12] System.out.println(Arrays.toString(cloned));
6.2 lambda 表达式
6.2.2. lambda 表达式
// 案例：字符串按长度排序的几种实现方式 // 方式1). 一般情况下，频繁调用 first.length() - second.length()； // 方式2). 通过实现 Comparator 接口 class LengthComparator implements Comparator<String> { public int compare(String first, String second) { return first.length() - second.length(); } } Arrays.sort(strings, new LengthComparator()); // 调用 // 方式3). Lambda 表达式： (String first, String second) -> first.length() - second.length();
表达式，3个部分构成：（参数）-> { 表达式 };
// 1）如果表达式不止一行，需要 {} + return (String first, String second) -> { if (first.length() < second.length()) return -1; else if (first.length() > second.length()) return 1; else return 0; } 2）无参数时，依然要有 空括号； () -> { for (int i = 100; i >= 0; i--) System.out.println(i); } 3）如可以推导出一个 lambda 表达式的参数类型，则可忽略其类型； Comparator<String> comp = (first, second) // same as (String first, String second) -> first.length() - second.length(); 4）如方法仅一个参数，且该参数的类型可推导出，那么 可以省略 ()； ActionListener listener = event -> // Instead of (event) -> ... or (ActionEvent event) -> ... System.out.println("The time is " + new Date()); 5）无需指定 lambda 表达式的返回类型，总会根据上下文推导出来； (String first, String second) -> first.length() - second.length() 6）如只在某些分支返回值，另外的不返回，则不合法； (int x) -> { if (x >=0 ) return 1; } // illegal，仅在 x>0 时返回值
// 案例： 对数组的排序 Arrays.sort()
var planets = new String[] {"Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune"};
// 1）. 默认的按字典排序 Arrays.sort(planets); // 2）. 按长度排序，lambda 表达式 Arrays.sort(planets, (first, second) -> first.length() - second.length());
6.2.3. 函数式接口
函数式接口（Functional Interface）：有且仅有一个抽象方法，需要这种接口的对象时，就可以提供一个 lambda 表达式。
Functional interface = Interface with a single abstract method.
Lambda expression can be used whenever a functional interface value is expected.
Conversion to a functional interface is the only thing that you can do with a lambda expression.
函数式接口可以被隐式转换为 lambda 表达式。
Lambda 表达式的初衷：取一个 Lambda 表达式，1）把它保存到一个接口类型的变量中；2）传递到一个需要接口类型值的方法；
1）函数式接口：
JDK 1.8 之前已有的函数式接口:
- java.lang.Runnable
- java.util.concurrent.Callable
- java.security.PrivilegedAction
- java.util.Comparator
- java.io.FileFilter
- java.nio.file.PathMatcher
- java.lang.reflect.InvocationHandler
- java.beans.PropertyChangeListener
- java.awt.event.ActionListener
- javax.swing.event.ChangeListener
JDK 1.8 新增加的函数接口：
- java.util.function
// 场景1：函数式接口 Comparator 的应用 -- 排序
String[] planets = {"Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune"};
Arrays.sort(planets, (first, second) -> first.length() - second.length());
=> 解析：
此处的 Arrays.sort() 方法调用的是 Arrays 类的 public static <T> void sort(T[] a, Comparator<? super T> c) {...}
其第二个参数是一个 Comparator 的实例，Comparator 是只有一个抽象方法的接口，所以可以提供一个 lambda 表达式。具体解释参照下面的（ActionListener、Comparator 接口为何是 函数式接口 的解释）
// 场景2：函数式接口 ActionListener 的应用 -- 事件发生器
lambda 表达式可以转换为接口，其解释为：下面例子的 Timer() 类的第二个参数是 ActionListener 接口，故可以将 lambda 表达式作为一个接口传入。
另外， lammbda 表达式代码相比实现了 ActionListener 接口的类比起来更易读：
// 方式一：通过实现 ActionListener 接口来实现 class TimePrinter implements ActionListener { @Override public void actionPerformed(ActionEvent e) { System.out.println("At the tone, the time is " + Instant.ofEpochMilli(e.getWhen())); Toolkit.getDefaultToolkit().beep(); } } // 调用 Timer t = new Timer(1000, listener); t.start();
// 方式二：通过 lambda 表达式实现（相比方式一，更易读） var t = new Timer(1000, event -> { // Timer(int delay, ActionListener listener)，其第二个参数也是 ActionListener，最终还是将 lambda 表达式传入 System.out.println("The timer is " +Instant.ofEpochMilli(e.getWhen())); Toolkit.getDefaultToolKit().beep(); }); t.start();
// ActionListener、Comparator 接口为何是 函数式接口 的解释：
1）ActionListener： 查看源码，它是仅一个 public 方法且没有方法实现，在接口中默认是抽象方法 public interface ActionListener extends EventListener { public void actionPerformed(ActionEvent e); } 2）Comparator 接口： public interface Comparator<T> { int compare(T o1, T o2); boolean equals(Object obj); default Comparator<T> reversed() { ... } ... public static <T extends Comparable<? super T>> Comparator<T> reverseOrder() { ... } ... } // 查看 Comparator 的源码，其包含的方法如上： a）boolean equals() 源自 Object.euqals(Object)，是对其的重写，已经有方法实现； b）其他 default、static 等方法都有具体实现； c）所以，推断出仅有 compare() 方式是没有方法实现的 抽象方法；
综合场景1、2：在 Java 中，对 lambda 表达式所能做的也只是转换为 函数式接口。
其他较常用的函数式接口包含：java.util.function.Predicate, java.util.function.Supplier
public class Java8Tester { public static void main(String[] args) { List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6); System.out.println("Print out all data:"); eval(list, n -> true); System.out.println("Print out all data > 3:"); eval(list, n -> n>3); } public static void eval(List<Integer> list, Predicate<Integer> predicate) { // Interface Predicate<T> has an abstract method boolen test(T t) for (Integer n : list) { if (predicate.test(n)) System.out.print(n + " "); } System.out.println(); } }
6.2.4 方法引用 Method References
// 应用场景：只要出现一个定时器事件，就打印这个事件对象
// 实现方式1： 函数式接口 var timer = new Timer(1000, event -> System.out.println(event)); // 实现方式2（Better solution): 方法引用 var timer = new Timer(1000, System.out::println); // 解析：指示编译器生成一个函数式接口的实例，覆盖这个接口的抽象方法来调用给定的方法。此例中，会生成一个 ActionListener，它的 actionPerformed(ActionEvent e) 方法要调用 System.out.println(e)。
|
方法引用的 3 种情况
|
|
| object::instanceMethod |
等价于 向方法传递参数的 lambda 表达式 如 System.out::println，对象是 System.out，等价于：x -> System.out.println(x) |
| Class::instanceMethod |
第一个参数会成为方法的隐式参数 如 String::compareToIgnoreCase，等价于： (x, y) -> x.compareToIgnoreCase(y) |
| Class::staticMethod |
所有参数都传递到静态方法 如 Math::pow，等价于： (x,y) -> Math.pow(x, y) |
注意：只有当 lambda 表达式的体只调用一个方法而不做其他操作时，才能把 lambda 表达式重写为方法引用。
如， s -> s.length == 0; // 这里有一个方法调用，还有一个比较，所以 不能使用方法引用。
// 关于方法引用的其他注释 1. 类似于 lambda 表达式，方法引用不是一个对象。不过，为一个类型为函数式接口的变量赋值时会生成一个对象；
2. 类似于 lambda 表达式，方法引用不能独立存在，总是会转换为 函数式接口 的实例； 3. 包含对象的方法引用 与 等价的 lambda 表达式还有一个细微的差别。如 方法引用 separator::equals，如果 seperator 为 null，那么： 1）构造 separator::equals 时立即抛出 NullPointerException； 2）lambda 表达式 x -> separator.equals(x) 只在调用时才会抛出 NullPointerException；
还可以在方法引用中使用 this、super
this::equals // 等同于 x -> this.equals(x)；
super::instanceMethod // 调用给定方法的超类版本
具体案例参考：https://www.w3cschool.cn/java/java-instance-method-reference.html
6.2.5 构造器引用
1. 构造器引用：Class::new
// 应用场景1： 将 字符串列表 转换为一个 对象列表
// 处理过程： 字符串 -> 流 -> 对象列表
ArrayList<String> names = ...; Stream<Person> stream = names.stream().map(Person::new); // map()会接受一个lambda 表达式，会为每个列表元素调用 Person(String) 构造器。Person::new, same as "s -> new Person(s)" List<Person> people = stream.collect(Collectors.toList());
2. 可以用数组元素建立构造器引用。 如 int[]::new // 它有一个参数，即数组的长度，等价于 lambda 表达式 "x -> new int[x]"
3. 无法构造泛型类型 T 的数组，因为构造任意类型的数组是不合法的。使用数组构造器就可以解决。
// 应用场景2：将 流 转换为 数组 Person[] people = stream.toArray(Person[]::new); // toArray() 调用这个构造器来得到一个有正确类型的数组，然后填充并返回这个数组
案例 参考： https://www.runoob.com/java/java8-method-references.html
6.2.6. 变量作用域 Variable Scope
lambda 表达式有 3 个部分：
- 1. A block of code 一个代码块；
- 2. Parameters 参数；
- 3. Value for the free variables 自由变量的值（不是在代码中定义的变量）； // 只能引用 值不会改变的变量
lambda 表达式的几个规则：
- 1）变量必须是最终变量（即初始化后，不会再赋予新值）。这是因为 Java 实现了闭包，可以捕获外围的变量值，使得外围方法在退出时，变量依然存在，但约束是该变量不可变；
- 2）表达式的体与嵌套块有相同的作用域。所以，方法中不能有同名的局部变量，声明与一个局部变量同名的参数或局部变量是不合法的；
- 3）lambda 表达式不能有同名的局部变量（因为归属一个方法）；
- 4）表达式中使用的 this，是调用 创建这个表达式的 方法的 this 参数；
- 5）不能改变 捕获的值；
// 1） lambda 表达式中的 i 根据 for 循环不断赋予新值 => error public static void repeat(String text, int count) { for (int i = 1; i <= count; i++) { ActionListener listener = event -> { System.out.println(i + ": " + text); } // Error: 1) Cannot refer to changing i new Timer(1000, listener).start(); } } // 2）变量冲突：variable first already defined Path first = Paths.get("/usr/bin"); Comparator<String> comp = (first, second) -> first.length() - second.length(); // 4） this public class Application() { public void init() { ActionListener listener = event -> { System.out.println(this.toString()); // this.toString() 会调用 Application 对象的 toString() ... } } } // 5) 不能改变捕获的值 public static void countDown(int start, int delay) { ActionListener listener = event -> { start--; // ERROR: 5) can't mutate captured variable System.out.println(start); }; new Timer(delay, listener).start(); }
6.2.7. 处理 lambda 表达式
使用 lambda 表达式的重点是 延迟执行（deferred execution）。适用的场景包括：
- 在一个单独的线程中运行代码；
- 多次运行代码；
- 在算法的适当位置运行代码（如，排序中的比较操作）；
- 发生某种情况时执行代码（如，点击一个按钮，数据到达等）；
- 只在必要时才运行；
// Example 1: Repeat an action n times: // step1: 解析成如下方法： repeat(10, () -> System.out.println("Hello, World!")); // step2: 实现： 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(); } // 调用 action.run() 时，会执行 lambda 表达式的主体 }
// Example2: 输出动作出现在哪一次的迭代中 // step1: 解析，需要一个合适的函数式接口，其中的方法有一个 int 参数且返回类型为 void，故选择接口 public interface IntConsumer { void accept(int value); } // step2: 改进 repeat 方法。 To pass the count to the action, pick a functional interface form java.utilfunction 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)));
6.2.8 再谈 Comparator 接口
// the static method comparing makes a comparator from a key extractor function: Arrays.sort(people, Compartor.comparing(Person::getName)); // 按 getName 的名字排序 // if the key is a primitive type, use comparingInt or comparingDouble to avoid boxing: Arrays.sort(words, Comparator.comparingInt(String::length)); // 按单次长度比较，比单纯使用 comparing 少一次装箱过程 // the default method then Comparing chains comparators: Arrays.sort(staff, Comparator.comparing(Employee::getName) .thenComparing(Person::getSalary));
6.3 内部类
内部类：定义在另一个类中的类。主要原因：
- 1）内部类方法可以访问该类定义所在的作用域中的数据， 包括私有的数据；
- 2）内部类可以对同一个包中的其他类隐藏；
- 3）当想要定义一个回调函数且不想编写大量代码时，使用匿名（anonymous) 内部类比较便捷（Before lambda expressions, inner classes were commonly used for callbacks）；
- !!! Java 8 中，内部类的很多用例已经被 Lambda 表达式所取代，不过偶尔还会有内部类用于其他一些用途，如限定类的作用域和信息隐藏
6.3.1 使用内部类访问对象状态：
内部类既可以访问自身的数据字段，也可以访问 创建它的外围类对象的数据字段
类与各sample的对应：内部类（TalkingClock） -> 局部内部类（TalkingClock2）-> 外部方法访问变量（TalkingClock3）-> 匿名内部类（TalkingClock4）-> Lambda 表达式（InnerClassLambda ））
// 内部类的用例
public class InnerClass { public static void main(String[] args) { TalkingClock clock = new TalkingClock(2000, true); clock.start(); JOptionPane.showMessageDialog(null, "Quit program?"); // keep program running until user selects "OK" System.exit(0); } } class TalkingClock { private int interval; private boolean beep; public TalkingClock(int interval, boolean beep) { this.interval = interval; this.beep = beep; } public void start() { var listener = new TimePrinter(); var t = new Timer(interval, listener); t.start(); } public class TimePrinter implements ActionListener { // 内部类，定义在 TalkingClock 内部的类 @Override public void actionPerformed(ActionEvent e) { System.out.println("At the tone, the time is " + new Date()); // beep 引用了创建 TimePrinter 类 的外部类 TalkingClock 对象的字段，简单理解即为 outer.beep，此 outer 为虚构语法，正确的是 TalkingClock.this，详见 6.3.2 节第1点说明 if (beep) Toolkit.getDefaultToolkit().beep(); } } }
// 外围类的引用在构造器中设置。编译器会修改所有的内部类的构造器， 添加一个对应外围类引用的参数。因为 TimePrinter 类没有定义构造器，所以编译器为这个类生成了一个无参数构造器，其代码如下所示： public TimePrinter(TalkingClock clock) { // automatically generated code outer = clock; }
6.3.2 内部类的特殊语法规则
1. 使用外围类引用的正规语法是： OuterClass.thispublic void actionPerformed(ActionEvent e) { ... if (TalkingClock.this.beep) { Toolkit.getDefaultToolkit().beep(); } } 2. 采用下列语法更明确地编写内部对象的构造器： outerObject.new InnerClass(construction parameters) ActionListener listener = this.new TimePrinter(); // 在这里，最新构造的 TimePrinter 对象的外围类引用被设置为创建内部类对象的方法的 this 引用 3. 也可以通过显式地命名将外围类引用设置为其他的对象。由于 TimePrinter 是一个公共内部类，在外围类的作用域之外，可以通过 OuterClass.InnerClass 引用内部类： TalkingClock jabberer = new TalkingClock(1000, true); TalkingClock.TimePrinter listener = jabberer.new TimePrinter(); // 语法规则： OuterClass.InnerClass object = outerClassObject.new InnerClass(); 4. 其他规范： 1）内部类中声明的所有静态字段必须是 final，并初始化为一个编译时常量； 2）内部类的 static 方法只能访问外围类的静态字段和方法；
6.3.4 局部内部类（Local Inner Classes）
局部类不能用 public 或 private 访问说明符进行声明。作用域被限定在声明这个局部类的块中。
局部类优势：对外界完全隐藏。 比内部类更隐蔽。即使 TalkingClock 类中的其他代码也不能访问它。除 start 方法之外， 没有任何方法知道 TimePrinter 类的存在。
// 6.3.1 内部类的用例中，TimePrinter 类仅在 start 方法中创建这个类型的对象时使用了一次，那么可以 在一个方法中定义局部类。 class TalkingClock2 { private int interval; private boolean beep; public TalkingClock2(int interval, boolean beep) { this.interval = interval; this.beep = beep; } public void start() {
// 局部内部类，无 public or private，对比于 6.3.1 的内部类，将 类的定义放置在类 TalkingClock 的一个方法中
class TimePrinter implements ActionListener { @Override public void actionPerformed(ActionEvent e) { 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(); } }
6.3.5 由外部方法访问变量
局部类的优点：
- 1）可以访问包含它们的外部类的字段；
- 2）可以访问 定义为 final 的 局部变量；
class TalkingClock3 { // 相对于 TalkingClock2 (6.3.4)，更是将变量 interval, beep 作为方法 start() 的参数，少了定义及初始化的过程。外部方法就可以直接访问这两个变量
public void start(int interval, final boolean beep) {
class TimePrinter implements ActionListener {
@Override
public void actionPerformed(ActionEvent e) {
System.out.println("At the tone, the time is " + new Date());
if (beep) Toolkit.getDefaultToolkit().beep(); // 内部类 TimePrinter 可以访问上面定义为 final 的变量 beep
}
}
ActionListener listener = new TimePrinter();
Timer t = new Timer(interval, listener);
t.start();
}
}
// 调用：
TalkingClock3 clock3 = new TalkingClock3();
clock3.start(1000, true);
6.3.6 匿名内部类（Anonymous Inner Classes）
class TalkingClock4 { public void start(int interval, boolean beep) { // new ActionListener() {...}; => {} 里面定义的就是 匿名内部类。
// 相比较 TalkingClock3（局部内部类），TimePrinter 只是实现 ActionListener 接口，且对外部隐藏。那么，无须定义该类，转而直接实现 ActionListener 接口 var listener = new ActionListener() { // 定义 listener 接口变量，new ActionListener() {...} 匿名内部类，实现了 ActionListener 接口，故可以赋值 @Override public void actionPerformed(ActionEvent e) { System.out.println("At the tone, the time is " + new Date()); if (beep) Toolkit.getDefaultToolkit().beep(); } }; var t = new Timer(interval, listener); t.start(); } }
使用内部类时，如果只想创建这个类的一个对象，甚至不需要为类指定名字，该类被称为 匿名内部类（annoymous inner class）。
1. Java 中可以实现一个类中包含另外一个类，且不需要提供任何的类名直接实例化； 2. 匿名类是不能有名字的类，它们不能被引用，只能在创建时用 new 语句来声明它们； 3. 匿名类不能有构造器，实际是将构造器参数传递给超类构造器。具体地说，只要内部类实现一个接口，就不能有任何构造参数； 4. 匿名类通常的语法格式： // SuperType：1)可以是接口（如 ActionListener），内部类就需要实现这个接口（例子参照上面的 TalkingClock4）；
2)可以是类，内部类就需要扩展这个类； new SuperType(construction parameters) { inner class methods and data } 匿名类的格式： class outerClass { object1 = new Type(parameterList) { // 定义一个匿名类 // 匿名类代码 }; }
5. 在内部类实现接口的时候，不能有任何构造参数，格式如： new InterfaceType() { methods and data }
6. 对比 构造类对象 与 构造匿名内部类的差异： Person queen = new Person("Mary"); // 构造一个类的对象 Person count = new Person("Dracula") {...}; // 构造了一个扩展了类的匿名内部类的对象，如果构造参数列表() 后跟一个 {}，那么就是定义 匿名内部类
7. 一般常用 匿名内部类实现事件监听和其他回调，如今更多使用 lambda 表达式；
// 匿名内部类 => 现在更多实用 lambda 表达式 class TalkingClock5 { public void start(int interval, boolean beep) { Timer t = new Timer(interval, event -> { // Lambda 表达式 System.out.println("At the tone, the time is " + new Date()); if (beep) { Toolkit.getDefaultToolkit().beep(); } }); t.start(); }
6.3.7 静态内部类
1) static inner class = inner class without reference to creating object 没有外部对象引用的内部类 2) useful for a private class that doesn't need to know the creating object 静态内部类的使用规则：只要内部类不需要访问外围类对象
静态内部类的其他特性： 1）与常规内部类不同，静态内部类可以有 静态字段 和 方法； 2）声明在接口中的内部类自动是 static 和 public； // Example：返回一个数组的最大、最小值，1）传统方式：使用2个方法分别计数最大、最小，数组遍历 2次；
2）better：只遍历一次数组，同时计数出最大、最小。那么返回值必须是两个数，正好使用类 Pair class ArrayAlg { public static class Pair { public double first; // 特性1：静态内部类的字段（静态字段，Java 8 以后不用特别指定为 final） public double second;
public Pair(double first, double second) {
this.first = first;
this.second = second;
}
public double getFirst() { return first; } // 特性2： 静态内部类的方法（静态方法）
... } ... public static Pair minmax(double[] values) { // 定义方法提供给 ArrayAlg 调用 ... return new Pair(min, max); // no creating object } } // Called as: ArrayAlg.Pair p = ArrayAlg.minmax(data); // 由于 Pair 这个词很大众化，所以需要将它定义为 ArrayAlg 的公共内部类，那么就可以通过 ArrayArg.Pair 来调用了
// 因为 ArrayAlg 直接调用 minmax() 而没有创建对象，就必须将 minmax() 声明为 static
// minmax() 方法中，使用 return new Pair() 而未创建对象，那么 Pair 类也必须声明为 static
6.4 服务加载器（Skipped）
6.5 代理（Skipped）
