关于java:方法引用

体验办法援用

// 定义一个接口
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 表达式被结构器代替的时候，它的形式参数全副传递给结构器作为参数