在Lamda新特性的支持下,JAVA8中可以使用lamda表达式来创建匿名方法。然而,有时候我们仅仅是需要调用一个已存在的方法(如java中已经定义好的方法),在这时候java8新特性“方法引用”将会进一步简化操作(注意:需要有Lamda的支持)。
方法引用的四种形式:
- 引用静态方法-->类名称::static 方法名称;
- 引用某个对象的实例的普通方法-->示例化对象::普通方法;
- 引用某个类型的任意对象的实例的普通方法-->特定类::普通方法;
- 引用构造方法-->类名称::new
引用静态方法
如:String类中的valueOf()方法:public static String valueOf(int x);
/**
* 实现方法的引用接口
* @param <P>引用方法的参数类型
* @param <R>引用方法的返回类型
*/
interface MyInterface<P,R>{
public R function(P p);//和String.valueOf(int x)类似
}
interface MyInterface1{
String function(Integer a);
}
public class Main {
public static void test(MyInterface1 myInterface1){
String result = myInterface1.function(2000);
System.out.println(result+" --");
}
public static void main(String[] args) {
//匿名内部类实现
test(new MyInterface1() {
@Override
public String function(Integer a) {
return String.valueOf(a);
}
});
//Lamda表达式实现
test((a)->String.valueOf(a));
//方法引用实现:引用类的静态方法
MyInterface<Integer,String> msg = String::valueOf;
String str = msg.function(2000);
System.out.println(str);
}
}
引用某个对象的实例的普通方法
如:String类中的toUpperCase()方法:public String toUpperCase();
这个方法没有参数,但是有返回值,并且这个方法一定要在有实例化对象的时候才可以调用。
interface MyInterface2<R>{
public R upper();
}
public class Main1 {
public static void main(String[] args) {
String str = new String("hello");
MyInterface2<String> msg = str::toUpperCase;
System.out.println(msg.upper());//调用upper方法,就相当于调用toUpperCase方法
}
}
在上面的演示中已经发现,如果要实现方法的引用,就必须要有接口,并且这个接口中只能存在一个方法,否则方法是无法进行引用的。
所以为了保证被引用的接口里面只能够定义一个方法,就要在接口上加以限制,使用@FunctionalInterface 注解。
@FunctionalInterface //此为函数式接口,只能够定义一个方法
interface MyInterface2<R>{
public R upper();
}
引用某个类型的任意对象的实例的普通方法
比如:String类中的compareTo(String str1,String str2)方法 public int compareTo(String anotherString);
如果要进行比较的话,比较的形式:字符串1对象.compareTo(字符串2对象),要准备两个参数。
@FunctionalInterface //此为函数式接口,只能够定义一个方法
interface StrCompare{
int compare(String a,String b);
}
public class Main2 {
public static void main(String[] args) {
//lambda表达式实现
//StrCompare msg = (a,b)->a.compareTo(b);
//方法引用实现
StrCompare msg = String::compareTo;
System.out.println(msg.compare("A","B"));
}
}
与之前相比,方法引用前不需要再定义对象,而是可以理解为将对象定义在了参数中。
引用构造方法
@FunctionalInterface //此为函数式接口,只能够定义一个方法
interface MyInterface4<C>{
public C person(String n,int a);
}
class Person{
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "姓名:"+this.name+",年龄:"+this.age;
}
}
public class Main3 {
public static void main(String[] args) {
MyInterface4<Person> msg = Person::new;//引用构造方法
Person person = msg.person("小明",20);
System.out.println(person);
}
}