tctip demo页面>

（原）

方法引用：

方法引用有4种：

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

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

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

这个方法，

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

default void sort(Comparator<? super E> c) {
    Object[] a = this.toArray();
    Arrays.sort(a, (Comparator) c);
    ListIterator<E> 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<Person7> 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中的唯一抽象方法：int compare(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中的抽象方法void accept(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方法，这个方法对应的抽象接口是int compare(T o1, T o2)，也就是说Person7::objectSortByAge是与int compare(T o1, T o2)对应起来的，这里的实例对象就是T o1，可以这么理解：o1.objectSortByAge(o2)，如果有多个参数，那么方法引用的实例就是第一个参数，后面的参数会按顺序当做实例方法的参数传进来。

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

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

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

public String getString(Supplier<String> 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类型，所以可以用String::new的方法，只是这里方法引用传不了参数。

如果我们想用构造方法引用的写法，又想把参数写进去，我们这可以将getString方法改成这样：

public String getString2(String p, Function<String, String> f){
   return f.apply(p) + " hello";
}

然后通过：

System.out.println(t.getString2("hehe", String::new));

这样的方法调用，这样就能将参数传入进来。

注意这里的getString2中的String::new不是调用String的new String()这个构造方法，而且调用的new String(String original)这个构造方法，因为Function中的抽象方法R apply(T t)是接收一个参数，返回一个参数。

 

继承：

由于java8中，抽象类新加入了default关键字，可以使得抽象方法中有了方法体。

如果有二个方法，都用了default方法，并且它们的方法名也一样，有一个类又同时实现了这二个接口，会出现什么情况呢？

比如这样：

interface MyInter1{
   default void sayHello(){
      System.out.println("hello");
   }
}

interface MyInter2{
   default void sayHello(){
      System.out.println("你好");
   }
}

然后我的Person7同时实现了这二个接口

public class Test7 implements MyInter1, MyInter2

然后编译器此时就会报错了，说Test7 继承了一个无法关联的default sayHello()

此时我们必需重载此方法

@Override
public void sayHello(){
   
}

如果我们想用MyInter2中的sayHello()，

则我们可以这么写：

@Override
public void sayHello(){
   MyInter2.super.sayHello();
}

这里   接口.super 可以找到特定的接口，然后再调用它的方法。用这种法就可以实现一个类实现多个接口，而这些接口中又有同相同的default方法名时，可以选取任意一个指定的接口中的default方法进行调用。

还有一种情况，类A实现了MyInter1接口，B继承了A同时又实现了MyInter2接口，这时你会发现，编译器通过了，没有报错，并且在调用B中的sayHello方法时，实际上是调用的类A中的sayHello方法，通过这里可以看出，其实这里存在一个优先级关系，即 类的优先级高于接口。

 例子请看这里：https://github.com/LeeScofield/java8