方法引用

体验方法引用

//定义一个接口
public interface Printable{
    void PrintString(String s);//接口中有且仅有一个抽象方法 没有返回值
}

//定义一个方法用这个接口作为参数
private static void usePrintable (Printable p){
    p.PrintString(s:"爱生活");
}

//定义主方法，在主方法中调用usePrintable方法
//直接使用Lambda表达式进行改进
usePrintable( (String s) -> {
    sout(s)
} );
//优化
usePrintable( s -> sout(s) );

用方法引用符 :: 进行改进(两个冒号)

usePrintable(System.out::println);
//System.out是一个对象
//用::引用里面的println方法
//可推导的就是可省略的 直接把参数s传给了println方法

方法引用符

• :: 该符号为引用运算符，而它所在的表达式被称为方法引用

//定义一个接口
public interface Printable{
    void PrintInt(int i);//接口中有且仅有一个抽象方法 没有返回值
}

//定义一个方法用这个接口作为参数
private static void usePrintable (Printable p){
    p.PrintInt(i:666);
}

//定义主方法，在主方法中调用usePrintable方法
//直接使用Lambda表达式进行改进
usePrintable( i -> sout(i) );

//用方法引用改进
usePrintable(System.out::println);

Lambda表达式支持的方法引用

常见引用方式

• 引用类方法
• 引用对象的实例方法
• 引用类的实例方法
• 引用构造器

引用类方法

• 格式：类名 :: 静态方法
• 范例：Interger::parseInt
  Interger类的方法：public static int parseInt(String s)将此String转换为int类型数据

练习

//定义一个接口
public interface Converter{
    void PrintString(String s);//接口中有且仅有一个抽象方法 没有返回值
}

//定义一个方法用这个接口作为参数
private static void useConverter (Converter c){
    int number = c.Converter(s:"666");
    sout(number);
}

//定义主方法，在主方法中调用useConverter方法
//直接使用Lambda表达式进行改进
useConverter( (String s) -> {
    return Integer.parseInt(s);
} );
//优化
useConverter( s -> Integer.parseInt(s); );

//用方法引用改进
useConverter(Integer::parseInt);

Lambda表达式被类方法替代的时候，它的形式参数全部传递给静态方法作为参数

引用对象的实例方法

引用对象的实例方法，其实就是引用类中的成员方法

• 格式：对象 :: 成员方法
• 范例："Hello World"::toUppCase
  String类的方法：public String toUppCase()将此String转换

练习

//定义一个接口
public interface Printer{
    void printUpperCase(String s);//接口中有且仅有一个抽象方法 没有返回值
}

//定义一个类，类里面有方法
public class PrintString{
    //把字符串参数变成大写的数据，然后再控制台输出
    public void printUpper(String s){
        String result = s.toUpperCase();
        sout(result);
    }
}

//定义一个方法用这个接口作为参数
private static void usePrinter (Printer p){
    p.printUpperCase(s:"HelloWorld");
}

//定义主方法，在主方法中调用usePrinter方法
//直接使用Lambda表达式进行改进
usePrinter( (String s) -> {
    String result = s.toUpperCase();
    sout(result);
} );
//优化
usePrinter( s -> sout(s.toUpperCase()) );

//用方法引用改进 已经存在这么一个方法
PrintString ps = new PrintString();
usePrinter(ps::printUpper);

Lambda表达式被对象的实例方法替代的时候，它的形式参数全部传递给该方法作为参数

引用类的实例方法

引用类的实例方法，其实就是引用类中的成员方法

• 格式：类名 :: 成员方法
• 范例：String :: substring
  String类的方法：public String substring(int beginIndex,int endIndex)
  从beginIndex开始到endIndex结束，截取字符串，返回一个子串，子串的长度为endIndex-beginIndex

练习

//定义一个接口
public interface MyString{
    String mySubString(String s,int x,int y);//接口中有且仅有一个抽象方法 没有返回值
}

//定义一个方法用这个接口作为参数
private static void useMyString (MyString my){
    String s = my.mySubString(s:"HelloWorld",x:2,y:5);
    sout(s);
}

//定义主方法，在主方法中调用useMyString 方法
//直接使用Lambda表达式进行改进
useMyString( (String s,int x,int y) -> {
    return s.subString(x,y);
} );
//优化
useMyString( (s,x,y) -> s.subString(x,y) );

//用方法引用改进 已经存在这么一个方法 引用类中的实例方法
useMyString(String::subString);

Lambda表达式被类的实例方法替代的时候，它的第一个参数作为调用者，后面的参数全部传递给该方法作为参数

引用构造器

引用构造器，其实就是引用构造方法

• 格式：类名 :: new
• 范例：Student :: new

练习

定义一个类，里面有两个成员变量name，age，并提供无参构造方法和带参构造方法，以及成员变量对应的get set方法

//定义一个接口
public interface StudentBuilder{
    Student build(String name,int age);//接口中有且仅有一个抽象方法 没有返回值
}

//定义一个方法用这个接口作为参数
private static void useStudentBuilder (StudentBuilder sb){
    Student s = sb.build(name:"林青霞",age:30)
    sout(s.getName()+","+s.getAge());
}

//定义主方法，在主方法中调用useStudentBuilder方法
//直接使用Lambda表达式进行改进
useStudentBuilder( (String name,int age) -> {
    Student s = new Student(name,age);
    return s;
    //等同于下面
    return new Student(name,age);
} );
//优化
useStudentBuilder( (name,age) -> new Student(name,age) );

//用方法引用改进 已经存在这么一个方法 引用类中的实例方法
useStudentBuilder(Student::new);

Lambda表达式被构造器替代的时候，它的形式参数全部传递给构造器作为参数