文章目录
方法引用
1.1方法引用使用
在使用L ambda表达式的时候,我们实际上传递进去的代码就是-种解决方案:拿参数做操作
那么考虑一种情况:如果我们在l ambda中所指定的操作方案,已经有地方存在相同方案,那是否还有必要再写重复逻辑呢?
答案肯定是没有必要
那我们又是如何使用已经存在的方案的呢?
这就是我们要讲解的方法引用,我们是通过方法引用来使用已经存在的方案
需求,
1:定义一个接口(Printable)·里面定义一个抽象方法. void printstring(String s);
2:定义一个测试类(PrintableDemo).在测试类中提供兩个方法
一个方法是. usePrintable(Printable p)
一个方法是主方法, 在主方法中調用usePrintable方法
public interface Printable {
void printstring(String s);
}
public class PrintableDemo {
public static void main(String[] args) {
//一个方法是主方法, 在主方法中調用usePrintable方法
//usePrintable((String s) ->{
//System.out.println(s);
//});
//参数类型可以省略
//只有一个参数 小括号可以省略
//代码块中只有一条语句 {} 可以省略
//优化
usePrintable(s -> System.out.println(s));
//这里的s的类型是根据接口的 printstring中的参数类型推导出来的
System.out.println("system.out的输出结果 Java");
//用方法引用 来 改进 方法引用符 ::
usePrintable(System.out::println);
//可推导的就是可省略的
}
private static void usePrintable(Printable p) {
p.printstring("Java");
}
}
输出结果:
Java
system.out的输出结果 Java
Java
1.2方法引用符
方法引用符
:: 该符号为引用运算符,而它所在的表达式被称为方法引用
Lamdba表达式: usePrintable(s -> System.out.println(s));
分析:拿到参数s之后通过Lambda表达式,传递给System.out.println方法去处理
方法引用:usePrintable(System.out::println);
分析:直接使用System.out中的println方法来取代Lambda,代码更加简洁
推导与省略
如果使用Lambda,那么根据“可推导就是可省略”的原则,无需指定参数类型,也无需指定的重载形式,它们都将被自动推导
如果使用方法引用,也是同样可以根据上下文进行推导
方法引用是Lambda的孪生兄弟
1.3Lambda表达式支持的方法引用
常见引用方式:
引用类方法
引用对象的实例方法
引用类的实例方法
引用构造器
1.4 引用类方法
就是引用类的静态方法
格式: 类名::静态方法
范例: Integer::parselnt
Integer类的方法: public static int parseInt(String s)将此String转换为int类型数据
练习:
1.定义一个接口(Converter), 里面定义-个抽象方法
int convert(String s);
2.定义一个测试类(ConverterDemo), 在测试类中提供两个方法
一个方法是: useConverter(Converter c)
一个方法是主方法,在主方法中调用useConverter方法
public class ConverterDemo {
public static void main(String[] args) {
Converter c = new Converter() {
@Override
public int convert(String s) {
return 0;
}
};
useConvertre((String s) ->{
return Integer.parseInt(s);
});
//改进
useConvertre(s -> Integer.parseInt(s));
//引用类方法
useConvertre(Integer::parseInt);
//Lambda表达式被类方法替代的时候,它的形式参数全部传递给静态方法作为参数
//多个参数都是直接传递
}
private static void useConvertre(Converter c) {
int number = c.convert("6662");
System.out.println(number);
}
}
public interface Converter {
int convert(String s);
}
1.5引用方法的实例方法
引用对象的实例方法,其实就引用类中的成员方法
格式:对象::成员方法
范例: “helloWorld” :: toUpperCase
Strin类中的方法:public String toUpperCase() 将此String所哟字符转化为大写
练习
1:定义一个类(PrintString),里面定义一个方法
public void printupper(String, s):把字符串参数变成大写的数据,然后在控制台输出
2:定义一个接口(Printer),里面定义一个抽象方法
void printUpperCase(String s)
3:定义一个测试类(PrinterDemo),在测试类中提供两个方法
一个方法是: usePrinter(Printer p)
一个方法是主方法,在主方法中实例PrintString,并引用对象的实例方法
public class PrinterDemo {
public static void main(String[] args) {
//引用对象的实例方法
PrintString ps = new PrintString();
usePrinter(ps::printupper);
//Lambda表达式被对象的实例方法替代的时候,它的形式参数全部传递给该方法作为参数
}
private static void usePrinter(Printer p) {
p.printUpperCase("HelloWorld");
}
}
public class PrintString {
//把字符串参数变成大写的数据,然后在控制台输出
public void printupper(String s) {
String result = s.toUpperCase();
System.out.println(result);
}
}
public interface Printer {
void printUpperCase(String s);
}
1.6引用类的实例方法
引用类的实例方法,其实就是引用类中的成员方法
格式:类名::成员方法
范例: String::substring
String类中的方法:public String substring(int beginIndex, int endIndex)
从beginindex开始到endIndex结束,截取字符串。返回一个子串,子串长度为endIndex-beginIndex
练习
1:定义一个接口(MyString),里面定义一个抽象方法:
string. mySubstring(string s,int. x,int );。
2:定义-一个测试类(MyStringDemo),在测试类中提供两个方法
一个方法是, uselMyString(Mystring my)
一个方法是主方法,在主方法中调用seMyString方法
public class MyStringDemo {
public static void main(String[] args) {
//在主方法中调用seMyString方法
useMyString((String s, int x, int y) ->{
return s.substring(x,y);
});
//改进
useMyString((s,x,y) -> s.substring(x,y));
//应用类的实例方法
useMyString(String :: substring);
//Lambda表达式被类的实例方法替代的时候
//第一个参数作为调用者
//后面的参数全部传递给该方法作为参数
}
private static void useMyString(MyString my) {
String s = my.mySubString("Helloworld", 2, 5);
System.out.println(s);
}
}
public interface MyString {
String mySubString(String s, int x, int y);
}
1.7引用构造器
其实就是引用构造方法
格式:类名::new
范例:Student::new
练习
1:定义-个类(Student), 里面有两个成员变量(name, age)
并提供无参构造方法和带参构造方法, 以及成员变量对应的get和set方法
2:定义一个接口(StudentBuilder),里面定义一个抽象方法
Student build(String name, int age);
3:定乂一个测试类(StudentDemo),在测试类中提供両个方法
一个方法是: useStudentBuilder(StudentBuilder s)
一个方法是主方法,在主方法中调用useStudentBuilder方法
public class StudentDemo {
public static void main(String[] args) {
//在主方法中调用useStudentBuilder方法
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表达式被构造器替代的时候,它的形式参数全部传递给构造器作为参数
}
private static void useStudentBuilder(StudentBuilder sb) {
Student s = sb.build("Collin", 22);
System.out.println(s.getName() + " - " + s.getAge());
}
}
public interface StudentBuilder {
Student build(String name, int age);
}
public class Student {
private String name;
private int age;
public Student(String name, int age) {
super();
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;
}
}