体验方法引用
通过方法引用，来使用已经存在的方案。
- 定义一个接口，里面有一个抽象方法：
public interface Printable {
void printString(String s);
}
- 定义一个测试类：
public class PrintDemo {
public static void main(String[] args) {
/*方式一
以Lambda表达式的方式，调用了接口的实现类，重写了接口中的方法
接口作为参数，实际上参数是接口的实现类*/
usePrintable(s -> System.out.println(s));
/*方式二
方法引用符 ::
参数s：可推导的就是可省略的*/
usePrintable(System.out::println);
}
/**
* 一个以接口对象为形式参数的方法
* @param p 接口对象
*/
private static void usePrintable(Printable p) {
System.out.println("卡塔尔世界杯");
}
}
- 运行结果：
卡塔尔世界杯
卡塔尔世界杯
方法引用符
:: 该符号为引用运算符，它所在的表达式被称为方法引用
推导与省略
- Lambda表达式：根据“可推导就是可省略”原则，无需指定参数类型，也无需指定重载形式，他们都将被自动推导
- 方法引用：同样可根据上下文推导
- Lambda表达式可以使用方法引用改进
- 定义一个接口，里面有一个抽象方法
public interface Printable1 {
void printInt(int i);
}
- 定义测试类
public class PrintDemo1 {
public static void main(String[] args) {
usePrintable(i -> System.out.println(i));
usePrintable(System.out::println);
}
private static void usePrintable(Printable1 p) {
p.printInt(123);
}
}
- 运行结果
123
123
Lambda表达式支持的方法引用
常见的引用方式
- 引用类方法
- 引用对象的实例方法
- 引用类的实例方法
- 引用构造器
引用类方法
引用类方法，其实就是引用类的静态方法
- 格式：类名::静态方法
- 定义一个接口，里面有一个抽象方法
public interface Convert {
int convert(String s);
}
- 定义一个测试类
public class ConvertDemo {
public static void main(String[] args) {
//Lambda
useConvert(s -> Integer.parseInt(s));
//引用类方法
//Lambda表达式被引用类方法替代时，它的形式参数全部传递给静态方法作为参数
useConvert(Integer::parseInt);
}
private static void useConvert(Convert c) {
int i = c.convert("123");
System.out.println(i);
}
}
- 运行结果
123
123
引用对象的实例方法
引用对象的实例方法，其实就是引用类中的成员方法
- 格式：对象::成员方法
- 定义一个类，里面有一个方法
public class PrintString {
/**
* 把字符串参数变成大写，输出到控制台
* @param s 字符串
*/
public void printUpper(String s){
System.out.println(s.toUpperCase());
}
}
- 定义一个接口，里面有一个抽象方法
public interface Printer {
void printUpperCase(String s);
}
- 测试类
public class PrinterDemo {
public static void main(String[] args) {
//Lambda表达式
usePrinter(s -> System.out.println(s.toUpperCase()));
//引用对象的实例方法
//对象::成员方法
//Lambda表达式被对象的实例化替代时，它的形式参数全部传递给该方法作为参数
usePrinter(new PrintString()::printUpper);
}
private static void usePrinter(Printer p){
p.printUpperCase("How are you");
}
}
- 运行结果
HOW ARE YOU
HOW ARE YOU
引用类的实例方法
引用类的实例方法，其实就是引用类中的成员方法
格式：类名::成员方法
- 定义一个接口，里面有一个抽象方法
public interface MyString {
String mySubString(String s, int x, int y);
}
- 定义一个测试类
public class MyStringDemo {
public static void main(String[] args) {
//Lambda表达式，截取字符串
useMyString((s, x, y) -> s.substring(x, y));
//引用类的实例方法
//第一个参数作为调用者
//后面的参数全部传递给该方法作为参数
useMyString(String::substring);
}
private static void useMyString(MyString m) {
System.out.println(m.mySubString("今天天气很凉快", 2, 6));
}
}
- 运行结果
天气很凉
天气很凉
引用构造器
引用构造器，其实就是引用构造方法
- 格式：类名::new
- 定义一个学生类，里面有两个成员变量（name,age），并提供无参构造方法和带参构造方法，以及成员变量的set和get方法
public class Student {
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
- 定义一个接口，里面有一个抽象方法
public interface StudentBuilder {
Student build(String name,int age);
}
- 定义一个测试类
public class StudentDemo {
public static void main(String[] args) {
//Lambda表达式
useStudentBuilder((a, b) -> new Student(a, b));
//引用构造器
//Lambda表达式被构造器替代的时候，它的形式参数全部传递给构造器作为参数
useStudentBuilder(Student::new);
}
private static void useStudentBuilder(StudentBuilder s) {
Student stu = s.build("钱学森", 28);
System.out.println(stu.getName() + "-" + stu.getAge());
}
}
- 运行结果
``java
钱学森-28
钱学森-28