java函数式接口报错static_Java8 函数式接口 与 Lambda 及 方法引用

函数式接口

Lambda 表达式只能在函数式接口上操作，函数式接口是具有单个抽象方法的接口，也称为 SAM(Single Abstract Method)

函数接口可以有任意的 default 或 static 方法

函数式接口例子

最基本的函数式接口

public interface Foo1 {

void bar();

}

public interface Foo1 {

int bar(boolean bz);

}

public interface Foo1 {

String bar(Object baz, int mink);

}

default 方法不会被计算到函数式接口的单个抽象方法里

public interface Foo1 {

default String bar() {

return "baz";

}

void quux();

}

可以使用 @FunctionalInterface 注解，该注解可以让编译器帮我们审核该接口是否函数式接口

@FunctionalInterface

public interface Foo1 {

void bar();

}

@FunctionalInterface

interface BlankFoo1 extends Foo1 { // 从Foo1继承抽象方法

}

@FunctionalInterface

interface Foo1 {

void bar();

boolean equals(Object obj); // 重写 Object 的方法因此不计算

}

下面不是一个函数式接口，因为它没有任何方法

@FunctionalInterface

interface Foo1 {}

Lambda 表达式

任何函数的参数只要是一个函数式接口都能接收一个 Lambda

案例准备：

public interface TestFunctionInterface1 {

void print();

}

public interface TestFunctionInterface2 {

void print(String name);

}

public interface TestFunctionInterface3 {

void print(String name,int age);

}

// 与静态方法

public static void print(TestFunctionInterface1 testFunctionInterface) {

testFunctionInterface.print();

}

public static void print(TestFunctionInterface2 testFunctionInterface) {

testFunctionInterface.print("linyuan");

}

public static void print(TestFunctionInterface3 testFunctionInterface) {

testFunctionInterface.print("linyuan", 21);

}

通过 Lambda(“闭包”或“匿名方法”)表达式

print(()->System.out.println("Hello"));

// 等同于

print(new TestFunctionInterface(){

@Override

public void print(){

System.out.println("Hello");

}

});

Lambda 表达式参数类型由编译推理得出，也可以显式的指定参数类型

Arrays.asList("a", "b", "c", "d").forEach((String e) -> System.out.println(e));

Lambda 表达式是匿名函数，因为函数式接口有一个抽象方法，所以 Java 重写了它，若 Lambda 类型不能确定，需要加上强制类型转换

TestFunctionInterface1 t1 = (TestFunctionInterface1)()->System.out.println("hello");

testFunctionInterface.print();

如果函数只有一个参数，可以省略圆括号，并且如果代码比较多，可以使用花括号括起来：

TestFunctionInterface2 t2 = name -> {System.out.println("my name is "+name);};

TestFunctionInterface3 t3 = (name,age) -> {System.out.println("my name is "+name+" and age "+age);};

如果Lambda中的代码是一个表达式而不是一个声明，它就会被当作一个返回值

IntUnaryOperator addOne = x -> x + 1;

使用 Lambda 表达式去排序一个集合，在 Java8 之前，排序一个集合的时候，需要用匿名内部类去实现 java.util.Comparator 接口：

// 匿名内部类方式：

List list = Arrays.asList("a", "c", "b");

list.stream().sorted(new Comparator() {

@Override

public int compare(String o1, String o2) {

return o1.compareTo(o2);

}

});

// Lambda 表达式方式：

List list = Arrays.asList("a", "c", "b");

list.stream().sorted((p1,p2)->p1.compareTo(p2));

Lambda 表达式(匿名类) 在访问外部局部变量时，其实是拷贝了一份外部局部变量的副本，修改副本的值是不会影响到外部局部变量的值的(因为Java只有值拷贝，没有引用拷贝，而外部局部变量的引用与Lambda表达式内部变量的引用并非同一个)，因此若欲想在 Lambda 表达式中修改外部局部变量的值，则会提醒需要将外部局部变量显式的声明为 final，以免开发者会误以为能够在 Lambda 表达式中修改外部局部变量的值

int number = 0;

IntStream.range(1, 3).forEach(i -> {

// 若无修改外部局部变量的值的操作，则无需声明为 final

System.out.println(number);

});

int number = 0;

IntStream.range(1, 3).forEach(i -> {

// 此处报错，Lambda 表达式中不能修改外部局部变量的值

// 因为 Lambda 表达式中的变量是外部局部变量的副本拷贝，修改副本的值不会影响原变量的值

// 需显示的声明 number 为 final

number = number + 1;

});

方法引用

方法引用是用来直接访问类或者实例已存在的方法或构造方法，可以理解为 Lambda 简化写法，使用 :: 来引用

@FunctionalInterface

public interface Supplier {

T get();

}

class Car {

//Supplier是jdk1.8的接口，这里和lamda一起使用了

public static Car create(final Supplier supplier) {

return supplier.get();

}

public static void collide(final Car car) {

System.out.println("Collided " + car.toString());

}

public void follow(final Car another) {

System.out.println("Following the " + another.toString());

}

public void repair() {

System.out.println("Repaired " + this.toString());

}

}

构造器引用

Car car = Car.create( Car::new );

List< Car > cars = Arrays.asList( car );

静态方法引用

cars.forEach( Car::collide );

特定类任意对象方法引用

cars.forEach( Car::repair );

特定对象的方法引用

Car police = Car.create( Car::new );

cars.forEach( police::follow );