1.对象名引用
引用对对象和方法都存在的 起到优化Lambda的作用
通过对象名引用成员方法 使用前提是对象名已经存在了,成员方法也是已经存在的 就可以使用对象名来引用成员方法
Printable 函数式接口
package Demo22;
/*
定义一个打印的函数式接口
*/
@FunctionalInterface
public interface Printable {
//打印字符串
public abstract void print(String s); //注意public abstract可以省略
}
MethodRerObject类中成员方法
package Demo22;
public class MethodRerObject {
//定义一个成员方法,传递一个字符串,把字符串按照大写输出
public void printUpperCaseString(String str){
System.out.println(str.toUpperCase());
}
}
psvm
package Demo22;
/*
通过对象名引用成员方法
使用前提是对象名已经存在了,成员方法也是已经存在的
就可以使用对象名来引用成员方法
*/
public class Demo01ObjectMethodRerObject {
//定义一个方法,方法的参数传递Printable接口
public static void printString(Printable p){
p.print("Hello");
}
public static void main(String[] args) {
//调用printString方法 方法的参数Printable
printString((String s )->{
//创建MethodRerObject对象
MethodRerObject obj = new MethodRerObject();
//调用MethodRerObject中的成员方法,把字符串按照大写输出
obj.printUpperCaseString(s);
});
/*
使用方法引用优化Lambda
对象时已经存在的MethodRerObject
成员方法也是已经存在的printUpperCaseString
所以我们可以使用对象名引用成员方法
*/
MethodRerObject obj = new MethodRerObject();
printString(obj::printUpperCaseString);
}
}
输出
2.类名引用静态成员方法
使用前提:
1.类已经存在 2.静态成员方法也已经存在
通过类名引用静态成员方法 类已经存在,静态方法也已经存在 就可以通过类名直接引用静态成员方法
函数类接口
package Demo22;
@FunctionalInterface
public interface Calculate {
//定义一个抽象方法,传递一个整数,对整数进行绝对值计算并返回
int calcAbs(int number);
}
psvm
package Demo22;
import Demo07.Calculator;
import com.sun.jdi.PathSearchingVirtualMachine;
/*
通过类名引用静态成员方法
类已经存在,静态方法也已经存在
就可以通过类名直接引用静态成员方法
*/
public class Demo02StaticMethodReference {
//定义一个方法,方法的参数传递要计算绝对值的整数和函数式接口
public static int method(int number, Calculate c){
return c.calcAbs(number);
}
public static void main(String[] args) {
int n = method(-10,(int nn)->{
//对参数进行绝对值的计算并返回结果
return Math.abs(nn); //Math数学工具类中的abs方法取绝对值 是一个静态方法
});
System.out.println(n);
/*
使用方法引用优化Lambda表达式
Math类是已经存在的
abs这个静态方法是已经存在的
所以我们可以直接通过类名引用静态方法
*/
int number2 = method(-10, Math::abs);
System.out.println(number2);
}
}
输出
10
10
3.super引用父类的成员方法
函数式接口
package Demo22;
/*
定义见面的函数式接口
*/
@FunctionalInterface
public interface Greetable {
//定义一个见面的方法
void greet();
}
父类
package Demo22;
/*
定义父类
*/
public class Human {
//定义一个sayHello
public void sayHello(){
System.out.println("Hello 我是Human");
}
}
子类 psvm
package Demo22;
/*
定义子类
*/
public class Man extends Human {
//子类重写父类的sayHello方法
@Override
public void sayHello() {
System.out.println("Hello 我是man");
}
//定义一个方法参数传递Greetable接口
public void method(Greetable g) {
g.greet();
}
public void show() {
//调用method方法,方法的参数Greetable是一个函数式接口,所以可以传递Lambda
/* method(()->{
//创建父类Human对象
Human h = new Human();
h.sayHello();
});*/
/*
因为有子父类关系所以存在一个关键字super 代表父类
所以我们可以直接使用super调用父类的成员方法
*/
method(() -> {
super.sayHello();
});//此代码与上面表达意思一样
//继续简化 使用super引用父类的成员方法 super是已经存在的 父类的成员方法sayHello也是存在的所以我们可以直接使用super引用父类的成员方法
// method(super::sayHello);//此代码与上面表达意思一样
}
public static void main(String[] args) {
new Man().show();
}
}
输出 Hello 我是Human
4.this引用本类的成员方法
this是直接可以使用本类的方法和变量
Richable函数式接口类
package Demo22;
/*
定义一个富有的函数式接口
*/
@FunctionalInterface
public interface Richable {
//定义一个想买什么就买什么的方法
void buy();
}
Husband psvm
package Demo22;
/*
通过this来引用本类的成员方法
*/
public class Husband {
//定义一个买房子的成员方法
public void buyHouse(){
System.out.println("有钱北京二环内一套四合院");
}
//定义一个结婚的方法,参数传递Richable方法
public void marry(Richable r){
r.buy();
}
//定义一个非常高兴的方法
public void soHappy(){
//调用结婚的方法,方法的参数Richable是一个函数式接口,所以可以传递Lambda表达式
marry(()->{
//使用this.成员方法调用本类买房子的方法
this.buyHouse();
});
//使用方法引用优化Lambda表达式
//this已经存在 本类的成员方法buyHouse也是已经存在的所以我们可以直接使用this来引用本的成员方法buyHouse
marry(this::buyHouse); //与上面代码意思相同
}
public static void main(String[] args) {
new Husband().soHappy();
}
}
输出:有钱北京二环内一套四