（原）
方法引用：
方法引用有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方法，通过这里可以看出，其实这里存在一个优先级关系，即 类的优先级高于接口。
