标签：extends 成员方法 vat 指定 使用方法 highlight 开发 父类 UNC
函数式接口在Java中是指：有且仅有一个抽象方法的接口。
函数式接口，即适用于函数式编程场景的接口。而Java中的函数式编程体现就是Lambda，所以函数式接口就是可以适用于Lambda使用的接口。只有确保接口中有且仅有一个抽象方法，Java中的Lambda才能顺利地进行推导。
修饰符 interface 接口名称 {
public abstract 返回值类型 方法名称(可选参数信息);
// 其他非抽象方法内容
}
public interface MyFunctionalInterface {
void myMethod();
}
@FunctionalInterface
public interface MyFunctionalInterface {
void myMethod();
}
一旦使用该注解来定义接口，编译器将会强制检查该接口是否确实有且仅有一个抽象方法，否则将会报错。需要注意的是，即使不使用该注解，只要满足函数式接口的定义，这仍然是一个函数式接口，使用起来都一样。
问题：为什么要使用该接口来验证一个接口是否是函数式接口呢？
如果一个接口是函数式接口，可以使用Lambda来简化代码的开发。
public class Demo09FunctionalInterface {
// 使用自定义的函数式接口作为方法参数
private static void doSomething(MyFunctionalInterface inter) {
inter.myMethod(); // 调用自定义的函数式接口方法
}
public static void main(String[] args) {
// 调用使用函数式接口的方法
doSomething(() -> System.out.println("Lambda执行啦！"));
}
}
函数式接口的定义：
@FunctionalInterface
public interface Eatable {
void eat();
}
应用场景代码：
/*
请定义一个函数式接口Eatable，内含抽象eat方法，
没有参数或返回值。使用该接口作为方法的参数，并进而通过Lambda来使用它。
*/
public class Demo01 {
public static void main(String[] args) {
//调用show方法
show(new Eatable() {
@Override
public void eat() {
System.out.println("吃饭了。。。。");
}
});
System.out.println("---------------------------");
show(()->System.out.println("吃饭了。。。。"));
}
/*
Eatable e = new Eatable() {
@Override
public void eat() {
System.out.println("吃饭了。。。。");
}
}
----------------------------------------------
Eatable e = ()->System.out.println("吃饭了。。。。")
*/
public static void show(Eatable e)
{
e.eat();
}
}
函数式接口的定义：
@FunctionalInterface
public interface Sumable {
int sum(int a, int b);
}
应用场景代码：
/*
请定义一个函数式接口Sumable，内含抽象sum方法，
可以将两个int数字相加返回int结果。使用该接口作为方法的参数，并进而通过Lambda来使用它。
*/
public class Demo01 {
public static void main(String[] args) {
//调用方法求两个数的和值
sumInt(3, 4, new Sumable() {
@Override
public int sum(int i, int j) {
return i+j;
}
});
System.out.println("-----------------------");
sumInt(3,4,(int i,int j)->i+j);//这里完成sum方法体的内容
}
//定义方法求两个数的和值
/*
int x=3 int y=4
Sumable lambda = new Sumable() {
@Override
public int sum(int i, int j) {
return i+j;
}
}
int x=3 int y=4
Sumable lambda = (int i,int j)->i+j
*/
public static void sumInt(int x,int y,Sumable lambda)
{
int sum = lambda.sum(x, y);
System.out.println("sum = " + sum);
}
}
@FunctionalInterface
public interface Printable {
//打印字符串str
void print(String str);
}
public class Demo02 {
public static void main(String[] args) {
//调用自定义方法
printString(new Printable() {
@Override
public void print(String s) {
System.out.println("s = " + s);
}
});
System.out.println("==============================");
printString(s -> System.out.println("s = " + s));
}
//自定义方法 Printable接口作为参数
/*
Printable pt = new Printable() {
@Override
public void print(String s) {
System.out.println("s = " + s);
}
}
*/
public static void printString(Printable pt)
{
//传递参数
pt.print("Hello 上海");
}
}
其中在printString方法中只管调用Printable接口的print方法，而并不管print方法的具体实现逻辑会将字符串打印到什么地方去。而main方法通过Lambda表达式指定了函数式接口Printable的具体操作方案为：拿到String（类型可推导，所以可省略）数据后，在控制台中输出它。
public class Demo02PrintRef {
private static void printString(Printable data) {
data.print("Hello, World!");
}
public static void main(String[] args) {
printString(System.out::println); //这种写法被称为方法引用
}
}
请注意其中的双冒号::写法，这种写法被称为“方法引用”，而双冒号是一种新的语法。
例如上例中，System.out对象中有一个重载的println(String)方法恰好就是我们所需要的。那么对于printString方法的函数式接口参数，对比下面两种写法，完全等效：
Lambda表达式写法：s -> System.out.println(s);
方法引用写法：System.out::println
第一种语义是指：拿到参数之后经Lambda之手，继而传递给System.out.println方法去处理。
第二种等效写法的语义是指：直接让System.out中的println方法来取代Lambda。两种写法的执行效果完全一样，而第二种方法引用的写法复用了已有方案，更加简洁。
如果使用Lambda，那么根据“可推导就是可省略”的原则，无需指定参数类型，也无需指定的重载形式——它们都将被自动推导。而如果使用方法引用，也是同样可以根据上下文进行推导。
函数式接口是Lambda的基础，而方法引用是Lambda的孪生兄弟。就是只要可以使用Lambda的地方都可以使用方法引用，没有使用Lambda表达式就不能使用方法引用。
下面这段代码将会调用println方法的不同重载形式，将函数式接口改为int类型的参数：
@FunctionalInterface
public interface PrintableInteger {
void print(int str);
}
由于上下文变了之后可以自动推导出唯一对应的匹配重载，所以方法引用没有任何变化：
public class Demo03PrintOverload {
private static void printInteger(PrintableInteger data) {
data.print(1024);
}
public static void main(String[] args) {
printInteger(System.out::println);
}
}
这次方法引用将会自动匹配到println(int)
这是最常见的一种用法，与上例相同。如果一个类中已经存在了一个成员方法：
在MethodRefObject类的方法printUpperCase中负责将参数str转换为大写。
public class MethodRefObject {
public void printUpperCase(String str) {
System.out.println(str.toUpperCase());
}
}
函数式接口仍然定义为：
@FunctionalInterface
public interface Printable {
void print(String str);
}
那么当需要使用这个printUpperCase成员方法来替代Printable接口的Lambda的时候，已经具有了MethodRefObject类的对象实例，则可以通过对象名引用成员方法，代码为：
Lambda表达式格式：(参数) -> {对象.方法名(参数)}
方法引用格式： 对象::方法名
/*
Lambda表达式格式：(参数) -> {对象.方法名(参数)}
方法引用格式： 对象::方法名
*/
public class MethodRefTest {
public static void main(String[] args) {
//创建对象
MethodRefObject methodRefObject = new MethodRefObject();
System.out.println("--------------匿名内部类形式---------------");
//调用自定义方法将指定的字符串变为大写
show("suoge", new Printable() {
@Override
public void print(String str) {
//使用methodRefObject对象调用方法
methodRefObject.printUpperCase(str);
}
});
System.out.println("--------------Lambda表达式形式---------------");
//调用自定义方法将指定的字符串变为大写
/*show("suoge",(String s2) -> {
//使用methodRefObject对象调用方法
methodRefObject.printUpperCase(s2);
});*/
//Lambda省略和推到形式
show("suoge", s2 -> methodRefObject.printUpperCase(s2));
System.out.println("--------------方法引用形式---------------");
//调用自定义方法将指定的字符串变为大写
/*
Lambda表达式格式：(参数) -> {对象.方法名(参数)}
方法引用格式： 对象::方法名
*/
show("suoge", methodRefObject::printUpperCase);
}
//自定义方法
public static void show(String s, Printable pt) {
//调用Printable接口中的方法将s变为大写
pt.print(s);
}
}
在这个例子中，下面两种写法是等效的：
Lambda表达式：s2 -> methodRefObject.printUpperCase(s2)
方法引用：methodRefObject::printUpperCase
使用方法引用前提：使用对象引用成员方法，要求必须有该对象。
public class Assistant {
public void dealFile(String file) {
System.out.println("帮忙处理文件：" + file);
}
}
请自定义一个函数式接口WorkHelper，其中的抽象方法help的预期行为与dealFile方法一致，并定义一个方法使用该函数式接口作为参数。通过方法引用的形式，将助理对象中的help
函数式接口可以定义为：
@FunctionalInterface
public interface WorkHelper {
void help(String file);
}
通过对象名引用成员方法的使用场景代码为：
public class DemoAssistant {
private static void work(WorkHelper helper) {
helper.help("机密文件");
}
public static void main(String[] args) {
Assistant assistant = new Assistant();
work(assistant::dealFile);
}
}
@FunctionalInterface
public interface Calcable {
int calc(int num);
}
第一种写法是使用Lambda表达式：
public class Demo05Lambda {
private static void method(int num, Calcable lambda) {
int x = lambda.calc(num);
System.out.println(x);
}
public static void main(String[] args) {
method(-10, n -> Math.abs(n));
}
}
但是使用方法引用的更好写法是：
public class Demo06MethodRef {
private static void method(int num, Calcable lambda) {
int x = lambda.calc(num);
System.out.println(x);
}
public static void main(String[] args) {
method(-10, Math::abs);
}
}
在这个例子中，下面两种写法是等效的：
Lambda表达式：
方法引用：Math::abs
public class StringUtils {
//定义一个成员方法判断是否为空
public static boolean isBlank(String s)
{
//"".equals(s.trim()去掉两端空格之后判断是否是空字符串
return s == null || "".equals(s.trim());
}
}
函数式接口的定义可以为：
@FunctionalInterface
public interface StringChecker {
boolean checkString(String str);
}
应用场景代码为：
public class Demo {
public static void main(String[] args) {
//调用自定义方法
/*methodCheck(" haha ",(s1)->{
return StringUtils.isBlank(s1);
});*/
//推到省略格式
// methodCheck(" ",s1->StringUtils.isBlank(s1));
//方法引用格式
methodCheck(" ",StringUtils::isBlank);
}
//定义自定义方法
public static void methodCheck(String s,StringChecker stringChecker)
{
boolean boo = stringChecker.checkString(s);
System.out.println("boo = " + boo);
}
}
@FunctionalInterface
public interface Greetable {
void greet();
}
public class Fu {
public void say() {
System.out.println("Fu 。。。Hello!");
}
}
public class Zi extends Fu {
@Override
public void say() {
method(() -> super.say());
}
private void method(Greetable lambda) {
lambda.greet();
System.out.println("I‘m a zi!");
}
}
public class Zi2 extends Fu {
@Override
public void say() {
method(super::say);
}
private void method(Greetable lambda) {
lambda.greet();
System.out.println("I‘m a zi2!");
}
}
在这个例子中，下面两种写法是等效的：
Lambda表达式：() -> super.say()
方法引用：
@FunctionalInterface
public interface Richable {
void buy();
}
public class Husband {
public void beHappy(){
marry(()-> System.out.println("买套房子"));
}
private void marry(Richable richable) {
richable.buy();
}
}
开心方法beHappy调用了结婚方法marry，后者的参数为函数式接口Richable，所以需要一个Lambda表达式。但是如果这个Lambda表达式的内容已经在本类当中存在了，则可以对Husband
public class Husband_1 {
private void buyHouse(){
System.out.println("买套房子");
}
public void beHappy(){
marry(()->this.buyHouse());
}
private void marry(Richable richable) {
richable.buy();
}
}
如果希望取消掉Lambda表达式，用方法引用进行替换，则更好的写法为：
public class Husband_1 {
private void buyHouse(){
System.out.println("买套房子");
}
public void beHappy(){
marry(this::buyHouse);
}
private void marry(Richable richable) {
richable.buy();
}
}
在这个例子中，下面两种写法是等效的：
Lambda表达式：() -> this.buyHouse()
方法引用：this::buyHouse
public class Person {
//成员变量
private String name;
//构造函数
public Person(String name) {
this.name = name;
}
public String getName() {
return name;
}
}
public interface PersonBuilder {
Person buildPerson(String name);
}
要使用这个函数式接口，可以通过Lambda表达式：
public class Demo09Lambda {
public static void main(String[] args) {
printName("赵丽颖",(String name)->{return new Person(name);});
}
private static void printName(String name,PersonBuilder builder) {
Person p = builder.buildPerson(name); //这一行代码中的builder哪里来的？
System.out.println(p.getName());
}
}
但是通过构造方法引用，有更好的写法：
public class Demo10ConstructorRef {
public static void printName(String name, PersonBuilder builder) {
Person p=builder.buildPerson(name);
System.out.println(p.getName());
}
public static void main(String[] args) {
printName("赵丽颖", Person::new);
}
}
在这个例子中，下面两种写法是等效的：
Lambda表达式：name -> new Person(name)
方法引用：Person::new
@FunctionalInterface
public interface ArrayBuilder {
int[] buildArray(int length);//length表示数组的长度
}
在应用该接口的时候，可以通过Lambda表达式：
public class Demo11ArrayInitRef {
private static int[] initArray(int length, ArrayBuilder builder) {
return builder.buildArray(length);
}
public static void main(String[] args) {
//int[] array = initArray(10, (length) ->{return new int[length];});
int[] array = initArray(10, length -> new int[length]);
}
}
但是更好的写法是使用数组的构造器引用：
public class Demo12ArrayInitRef {
private static int[] initArray(int length, ArrayBuilder builder) {
return builder.buildArray(length);
}
public static void main(String[] args) {
int[] array = initArray(10, int[]::new); //方法引用
}
}
在这个例子中，下面两种写法是等效的：
Lambda表达式：length -> new int[length]
方法引用：
标签：extends 成员方法 vat 指定 使用方法 highlight 开发 父类 UNC
原文地址：https://www.cnblogs.com/xinruyi/p/11030180.html
