java8调用继承_Java 8 新特性7-方法引用、继承-CSDN博客

本文链接：https://blog.csdn.net/weixin_39685578/article/details/114607729

(原)

方法引用：

方法引用有4种：

1、静态方法引用：类名::静态方法名

在java中，对集合的排序，我们常用java提供的

Collections.sort(List list, Comparator super T> c)

这个方法，

而在java8中，排序方法被作为了一个默认方法加入了List集合中。

default void sort(Comparator super E> c) {

Object[] a = this.toArray();

Arrays.sort(a, (Comparator) c);

ListIterator i = this.listIterator();

for (Object e : a) {

i.next();

i.set((E) e);

}

这个与Collections.sort(list,comparator)类似，需要传入一个Comparator比较器。(Comparator在java8中已经是一个函数式接口了。)

如果我有这样一个model类：

class Person7{

private String name;

private Integer age;

public Person7(String name, Integer age) {

super();

this.name = name;

this.age = age;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public Integer getAge() {

return age;

}

public void setAge(Integer age) {

this.age = age;

}

public static int sortByAge(Person7 p1,Person7 p2){

return p1.getAge() - p2.getAge();

}

public static int sortByName(Person7 p1,Person7 p2){

return p1.getName().compareToIgnoreCase(p2.getName());

}

public int objectSortByAge(Person7 p){

return this.age - p.getAge();

}

然后对这个model对象的age,name排序，

先创建一个Person7的List集合：

Person7 p1 = new Person7("zhaoda", 25);

Person7 p2 = new Person7("wanger",19);

Person7 p3 = new Person7("zhangsan",46);

Person7 p4 = new Person7("lisi",23);

List list = Arrays.asList(p1,p2,p3,p4);

用常用的lambda表达式进行排序，然后输出:

list.sort((a , b) -> Person7.sortByAge(a, b));

list.forEach(a -> System.out.println(a.getAge()));

如果用静态方法引用，那么就应该这么写：

list.sort(Person7::sortByAge);

sortByAge方法接收二个同类型参数，并且返回一个int类型，这种结构完全符合Comparator中的唯一抽象方法：intcompare(T o1, T o2);

所以这里的Person7::sortByAge与(a , b) -> Person7.sortByAge(a, b)是等价的。

(注意：方法引用是不能传任何参数的)

2、对象名::实例方法名

接上面的例子，现在将上面排序的方法拿出来，单独放在SortUtil7类中。

class SortUtil7{

public int sortByAge(Person7 p1,Person7 p2){

return p1.getAge() - p2.getAge();

}

public int sortByName(Person7 p1,Person7 p2){

return p1.getName().compareToIgnoreCase(p2.getName());

}

我们先创建一个SortUtil7对象，然后用lambda表达式进行排序并输出：

SortUtil7 sort = new SortUtil7();

list.sort((a,b) -> sort.sortByAge(a, b));

list.forEach(a -> System.out.println(a.getAge()));

然后我们换对象方法引用去做同样的事：

list.sort(sort::sortByAge);

list.forEach(a -> System.out.println(a.getAge()));

再看看这段代码：

list.forEach(a -> System.out.println(a.getAge()));

这里可以替换成：

list.forEach(System.out::println);

这里的System.out是一个静态的对象

public final static PrintStream out = null;

这个out对象的println方法是这样的：

public void println(Object x) {

String s = String.valueOf(x);

synchronized (this) {

print(s);

newLine();

}

接收一个Object类型的参数没有返回值，与forEach方法的参数Consume中的抽象方法voidaccept(T t)完全一致，所以这里

list.forEach(System.out::println);

这种方法引用属于第里的第二种，对象名::实例方法。

3、类名::实例方法名

这种方法引用是4种方法引用中最难理解的一种，这种写法与第一种写没有必然的联系。

接上面的例子，在Person7中有一个实例方法，

public int objectSortByAge(Person7 p){

return this.age - p.getAge();

}

这个方法让一个实例与传进参数的那个实例进行比较。

然后用方法去调用并输出：

list.sort(Person7::objectSortByAge);

list.forEach(a -> System.out.println(a.getAge()));

这种方法引用之所以难以理解，是因为实例方法被调用了，却在代码中看到不是哪个实例调用的。但是要知道的是实例方法被调用了，一定是有一个实例对象，那么这个实例对象是哪个呢？

让我们回过头来看看sort方法，这个方法对应的抽象接口是intcompare(T o1, T o2)，也就是说Person7::objectSortByAge是与intcompare(T o1, T o2)对应起来的，这里的实例对象就是T o1，可以这么理解：o1.objectSortByAge(o2)，如果有多个参数，那么方法引用的实例就是第一个参数，后面的参数会按顺序当做实例方法的参数传进来。

4、构造方法引用:类名::new

这种方法引用比较好理解了。

接上面的例子，在Person7中创建一个方法：

public String getString(Supplier supplier){

return supplier.get() + " hello";

}

然后创建一个Person7对象，用lambda的方法这个方法调用一下。

Test7 t = new Test7();

System.out.println(t.getString(() -> "123"));

这里换成构造方法引用：

System.out.println(t.getString(String::new));

因为这里的Supplier不接收参数，返回一个String类型，所以可以用String::new的方法，只是这里方法引用传不了参数。