方法引用

體驗方法引用

//定義一個接口
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表達式被構造器替代的時候，它的形式參數所有傳遞給構造器做爲參數