方法引用
方法引用体验
public interface Printable {
void pringstring(String s);
}
public class PrintableDemo {
public static void main(String[] args) {
usePrintable((String s)->{//lamda表达式
System.out.println(s);
});
usePrintable(s->System.out.println(s));//简化
//方法引用符::
usePrintable(System.out::println);//可推导的就是可省略的
}
private static void usePrintable(Printable p){
p.pringstring("你好Java!");
}
}
lamda表达式可参考lamda表达式详解
方法引用符
方法引用运算符
::为方法引用运算符,所在表达式被称为方法引用
回顾一下
- Lambda表达式:usePrintable(s->Sysout.out.println(s))
分析:拿到参数s之后,通过lambda表达式,传递给System.out.println方法去处理 - 方法引用:usePrintable(System.out::println)
分析:直接使用System.out中的println方法来取代Lambda,代码更简洁
推导与省略
- 如果使用Lambda,那么根据“可推导就是可省略的”原则,无需指定参数类型,也无需指定重载形式,他们都将被自动推导
- 如果使用方法引用,也是同样可以根据上下文进行推导
常见的引用方式
引用类方法
引用类方法就是引用类的静态方法
- 格式: 类名::静态方法
- 范例: Integer::parseInt
public interface Converter{
int convert(String s);
}
public class ConverterDemo{
public static void main(String[] args){
useConverter((String s)->{
return Integer.parseInt(s);
});
useConverter(s->Integer.parseInt(s));
//引用类方法
useConverter(Integer::parseInt);
}
private static void useConverter(Converter c){
int num=c.convert("666");
System.out.println(num);
}
}
lambda表达式被类方法替代的时候,形式参数全部传递给静态方法作为参数
引用对象的实例方法
**引用对象的实例方法,实质上是引用类中的成员方法 **
- 格式 对象::成员方法
- 范例 HelloWorld::toUpperCase
public interface Printer{
void printUpperCase(String s);
}
public class PrintString{
public void printUpper(String s){
String result=s.toUpperCase();
System.out.println(result);
}
}
public class PrintUpperDemo{
public static void main(String[] args){
usePrinter((String s)->{
String result = s.toUpperCase();
System.out.priintln(result);
});
usePrinter( s->
System.out.priintln(s.toUpperCase()));
//引用对象实例
PrintString ps=new PrintString();
usePrinter(ps::printUpper);
}
private static usePrinter(Printer p){
p.printUpperCase("Hello");
}
}
lambda表达式被对象的实例方法替代的时候,形式参数全部传递给该方法作为参数
引用类的实例方法
**引用对象的实例方法,实质上是引用类中的成员方法 **
- 格式 类名::成员方法
- 范例 String::substring
public interface Mystring{
String mySubString(String s,int x,int y);
}
public class MyStringDemo(){
public static void main(String[] args){
useMyString((String s,int x,int y)->{
return s.substring(x,y);
})
useMyString((s,x,y))->s.substring(x,y));
useMySting(String::substring);
}
private static useMyString(MyString my){
String s=my.mySubString("HelloWorld",2,5);
System.out.println(s);
}
}
lambda表达式被类的实例方法替代的时候,第一个参数作为调用者,后面的参数全部传递给该方法作为参数
引用构造器
**引用构造器,实质上是引用构造方法 **
- 格式 类名::new
- 范例 Student::new
public class Student{
private String name;
private int age;
public Student(){
}
public Student(String name,int age){
this.name=name;
this.age=age;
}
public void setName(String name){
this.name=name;
}
public String getName(){
return name;
}
public void setAge(int age){
this.age=age;
}
public int getAge(){
return age;
}
}
public interface StudentBuilder{
Student build(Stringname,int age);
}
public class StudentDemo{
public static void main(String[] args){
useStudentBulilder((String name,int age)->{
Student s=new Student(name,age);
return s;
})
useStudentBulilder((name,age)->new Student(name,age));
//引用构造器
useStudentBulilder(Student::new);
}
private static void useStudentBuilder(StudentBuilder sb){
Student s=sb.build("R","18");
System.out.println(s.getName()+","+s.getAge());
}
}
lambda表达式被构造器替代的时候,所有的形式参数全部传递构造方法作为参数