【java新特性】之方法引用与Lambda表达式

在lamda新特性的支持下，java8中可以使用lamda表达式来创建匿名方法。然而，有时候我们仅仅是需要调用一个已存在的方法（如java中已经定义好的方法），在这时候java8新特性“方法引用”将会进一步简化操作（注意：需要有lamda的支持）。

方法引用的四种形式：

• 引用静态方法-->类名称::static 方法名称；
• 引用某个对象的实例的普通方法-->示例化对象::普通方法；
• 引用某个类型的任意对象的实例的普通方法-->特定类::普通方法；
• 引用构造方法-->类名称::new

引用静态方法

　　如：string类中的valueof()方法：public static string valueof(int x);

 1 /**
 2  * 实现方法的引用接口
 3  * @param <p>引用方法的参数类型
 4  * @param <r>引用方法的返回类型
 5  */
 6 interface myinterface<p,r>{
 7     public r function(p p);//和string.valueof(int x)类似
 8 }
 9 
10 interface myinterface1{
11     string function(integer a);
12 }
13 
14 public class main {
15 
16     public static void test(myinterface1 myinterface1){
17         string result = myinterface1.function(2000);
18         system.out.println(result+"  --");
19     }
20 
21     public static void main(string[] args) {
22 
23         //匿名内部类实现
24         test(new myinterface1() {
25             @override
26             public string function(integer a) {
27                 return string.valueof(a);
28             }
29         });
30 
31         //lamda表达式实现
32         test((a)->string.valueof(a));
33 
34         //方法引用实现:引用类的静态方法
35         myinterface<integer,string> msg = string::valueof;
36         string str = msg.function(2000);
37         system.out.println(str);
38     }
39 }

引用某个对象的实例的普通方法

　　如：string类中的touppercase()方法：public string touppercase();

　　这个方法没有参数，但是有返回值，并且这个方法一定要在有实例化对象的时候才可以调用。

 1 interface myinterface2<r>{
 2     public r upper();
 3 }
 4 public class main1 {
 5     public static void main(string[] args) {
 6         string str = new string("hello");
 7         myinterface2<string> msg = str::touppercase;
 8         system.out.println(msg.upper());//调用upper方法，就相当于调用touppercase方法
 9     }
10 }

　　在上面的演示中已经发现，如果要实现方法的引用，就必须要有接口，并且这个接口中只能存在一个方法，否则方法是无法进行引用的。

　　所以为了保证被引用的接口里面只能够定义一个方法，就要在接口上加以限制，使用@functionalinterface 注解。

1 @functionalinterface   //此为函数式接口，只能够定义一个方法
2 interface myinterface2<r>{
3     public r upper();
4 }

引用某个类型的任意对象的实例的普通方法

　　比如：string类中的compareto(string str1,string str2)方法 public int compareto(string anotherstring);

　　如果要进行比较的话，比较的形式：字符串1对象.compareto(字符串2对象)，要准备两个参数。

 1 @functionalinterface   //此为函数式接口，只能够定义一个方法
 2 interface myinterface3<p>{
 3     public int compare(p p1,p p2);
 4 }
 5 public class main2 {
 6     public static void main(string[] args) {
 7         myinterface3<string> msg = string::compareto;
 8         system.out.println(msg.compare("a","b"));
 9     }
10 }

　　与之前相比，方法引用前不需要再定义对象，而是可以理解为将对象定义在了参数中。

引用构造方法

 1 @functionalinterface   //此为函数式接口，只能够定义一个方法
 2 interface myinterface4<c>{
 3     public c person(string n,int a);
 4 }
 5 class person{
 6     private string name;
 7     private int age;
 8 
 9     public person(string name, int age) {
10         this.name = name;
11         this.age = age;
12     }
13     @override
14     public string tostring() {
15         return  "姓名："+this.name+",年龄："+this.age;
16     }
17 }
18 public class main3 {
19     public static void main(string[] args) {
20         myinterface4<person> msg = person::new;//引用构造方法
21         person person = msg.person("小明",20);
22         system.out.println(person);
23     }
24 }