在Lamda新特性的支持下，JAVA8中可以使用lamda表达式来创建匿名方法。然而，有时候我们仅仅是需要调用一个已存在的方法(如java中已经定义好的方法)，在这时候java8新特性“方法引用”将会进一步简化操作(注意：需要有Lamda的支持)。
方法引用的四种形式：
引用静态方法-->类名称::static 方法名称；
引用某个对象的实例的普通方法-->示例化对象::普通方法；
引用某个类型的任意对象的实例的普通方法-->特定类::普通方法；
引用构造方法-->类名称::new
引用静态方法
如：String类中的valueOf()方法：public static String valueOf(int x);
1 /**
2 * 实现方法的引用接口
3 * @param
引用方法的参数类型
4 * @param引用方法的返回类型
5 */
6 interface MyInterface
{
7 public R function(P p);//和String.valueOf(int x)类似
8 }
9
10 interfaceMyInterface1{
11 String function(Integer a);
12 }
13
14 public classMain {
15
16 public static voidtest(MyInterface1 myInterface1){
17 String result = myInterface1.function(2000);
18 System.out.println(result+" --");
19 }
20
21 public static voidmain(String[] args) {
22
23 //匿名内部类实现
24 test(newMyInterface1() {
25 @Override
26 publicString function(Integer a) {
27 returnString.valueOf(a);
28 }
29 });
30
31 //Lamda表达式实现
32 test((a)->String.valueOf(a));
33
34 //方法引用实现:引用类的静态方法
35 MyInterface msg =String::valueOf;
36 String str = msg.function(2000);
37 System.out.println(str);
38 }
39 }
引用某个对象的实例的普通方法
如：String类中的toUpperCase()方法：public String toUpperCase();
这个方法没有参数，但是有返回值，并且这个方法一定要在有实例化对象的时候才可以调用。
1 interface MyInterface2{
2 publicR upper();
3 }
4 public classMain1 {
5 public static voidmain(String[] args) {
6 String str = new String("hello");
7 MyInterface2 msg =str::toUpperCase;
8 System.out.println(msg.upper());//调用upper方法，就相当于调用toUpperCase方法
9 }
10 }
在上面的演示中已经发现，如果要实现方法的引用，就必须要有接口，并且这个接口中只能存在一个方法，否则方法是无法进行引用的。
所以为了保证被引用的接口里面只能够定义一个方法，就要在接口上加以限制，使用@FunctionalInterface 注解。
1 @FunctionalInterface //此为函数式接口，只能够定义一个方法
2 interface MyInterface2{
3 publicR upper();
4 }
引用某个类型的任意对象的实例的普通方法
比如：String类中的compareTo(String str1,String str2)方法 public int compareTo(String anotherString);
如果要进行比较的话，比较的形式：字符串1对象.compareTo(字符串2对象)，要准备两个参数。
1 @FunctionalInterface //此为函数式接口，只能够定义一个方法
2 interface MyInterface3
{
3 public intcompare(P p1,P p2);
4 }
5 public classMain2 {
6 public static voidmain(String[] args) {
7 MyInterface3 msg =String::compareTo;
8 System.out.println(msg.compare("A","B"));
9 }
10 }
与之前相比，方法引用前不需要再定义对象，而是可以理解为将对象定义在了参数中。
引用构造方法
1 @FunctionalInterface //此为函数式接口，只能够定义一个方法
2 interface MyInterface4{
3 public C person(String n,inta);
4 }
5 classPerson{
6 privateString name;
7 private intage;
8
9 public Person(String name, intage) {
10 this.name =name;
11 this.age =age;
12 }
13 @Override
14 publicString toString() {
15 return "姓名："+this.name+",年龄："+this.age;
16 }
17 }
18 public classMain3 {
19 public static voidmain(String[] args) {
20 MyInterface4 msg = Person::new;//引用构造方法
21 Person person = msg.person("小明",20);
22 System.out.println(person);
23 }
24 }