- λ希腊字母表中排序第十一位的字母
- 避免匿名内部类定义过多，使得代码更加简洁
- 其实质属于函数式编程的概念
(params)->expression[表达式]
(params)->statement[语句]
(params)->{statements}
lambda表达式推导过程：
- 创建一个类，重写接口中的抽象方法
class Demo16{ public static void main(String[] args){ Test test=new Test(); int sum = test.add(5,6); System.out.println(sum); } } interface inter{ int add(int a,int b); } class Test implements inter{ public int add(int a,int b) { return a+b; } }
- 使用静态内部类
class Demo16{ static class Test implements inter{ public int add(int a,int b) { return a+b; } } public static void main(String[] args){ Test test=new Test(); int sum = test.add(5,6); System.out.println(sum); } } interface inter{ int add(int a,int b); }
- 局部内部类
class Demo16{ public static void main(String[] args){ class Test implements inter{ public int add(int a,int b) { return a+b; } } Test test=new Test(); int sum = test.add(5,6); System.out.println(sum); } } interface inter{ int add(int a,int b); }
- 匿名内部类
class Demo16{ public static void main(String[] args){ inter test=new inter(){ public int add(int a,int b) { return a+b; } }; int sum = test.add(5,6); System.out.println(sum); } } interface inter{ int add(int a,int b); }
- 用lambda简化
class Demo16{ public static void main(String[] args){ inter test=(a,b)->a+b; int sum = test.add(5,6); System.out.println(sum); } } interface inter{ int add(int a,int b); }
函数式接口
- 使用lambda表达式的前提条件: **
必须是接口**，且接口中只包含唯一一个抽象方法（有且仅有一个必须被重写的方法），这样的接口叫函数式接口。
@FunctionalInterfaces
public interface Runnable{
public abstract void run();
}
- @FunctionalInterface
检测是否是函数式接口
函数式接口判断
interface inter1{//是函数式接口 void show(); } interface inter2{//不是函数式接口 void show(); void test(); } interface inter3 extends inter1{}//是函数式接口 interface inter4{//是函数式接口 void show(); static void ff(){ System.out.println("ff"); } } interface inter5{//是函数式接口 void ff(); default void show(){ System.out.println("show"); } } interface inter6{//是函数式接口 void show(); String toString();//不需要被重写 } @FunctionalInterface //检测是否是函数式接口 interface inter7{}//不是函数式接口 class Demo17{ public static void main(String[] args){…………} }
简化书写
- 大括号中只有一行代码，那么大括号可以省略
- 大括号中只有一行代码，且这行代码是返回语句，那么return可以省
- 只有一个参数，小括号可以省；没有参数，小括号不可以省
- 数据类型可以省，数据类型要省都省
练习
lambda表达式的练习
interface NoneParamNoneReturn{
void test();
}
interface OneParamNoneReturn{
void test(int a);
}
interface MultiParamNoneReturn{
void test(int a,int b);
}
interface NoneParamAndReturn{
int test();
}
interface OneParamAndReturn{
int test(int a);
}
interface MultiParamAndReturn{
int test(int a,int b);
}
class Demo18{
public static void main(String[] args){
//使用lambda表达式实现接口
……………………
}
}
NoneParamNoneReturn inter1=() -> sop("hehe");
inter1.test();
OneParamNoneReturn inter2= a-> sop(a);
inter2.test(6);
MultiParamNoneReturn inter3=(a,b) -> sop(a+b);
inter3.test(5,6);
NoneParamAndReturn inter4=()->66;
sop(inter4.test());
OneParamAndReturn inter5=a-> a;
sop(inter5.test(44));
MultiParamAndReturn inter6=(a,b)->a+b;
sop(inter6.test(11,88));
方法引用 : :
静态方法引用
函数式接口中的方法的参数及返回值和被引用的方法的参数及返回值一致
非静态方法引用
class Demo {
public static void main(String[] args){
//静态方法引用
inter in=Calculate::calculate;//(a,b)->a+b;
//非静态方法引用
inter in=new Calculate()::calculate;//(a,b)->a+b;
int num=in.test(5,6);
System.out.println(num);
}
}
interface inter{
int test(int a,int b);
}
class Calculate{
public static int calculate(int a,int b){
return a+b;
}
}
构造方法引用
函数式接口中的方法的返回值是一个引用类型，参数和构造方法一致
class Demo4{
public static void main(String[] args){
inter in=Person::new;//()->new Person();
Person ren1=in.test();
System.out.println(ren1);//null,0
inter2 in2=Person::new;
//(name,age)->new Person("李四",20);
Person ren2=in2.test("李四",20);
System.out.println(ren2);//李四,20
}
}
interface inter{
Person test();
}
interface inter2{
Person test(String name,int age);
}
class Person{…………}
其他引用
- 函数式接口中的方法的参数是引用类型，方法的实现只是调用该引用类型参数的某个方法
- 函数式接口中的方法的一个参数是引用类型，其余参数是调用该引用类型参数的某个方法需要接收的参数
- 函数式接口中的方法的参数是引用类型，方法的实现只是调用该引用类型的参数的某个方法
class Demo3{
public static void main(String[] args) {
ShowInfo show1=Person::show;//person->person.show();
show1.showInfo(new Person());
SetInfo sets=Person::setName;
//(person,name)->person.setName(name)
sets.setInfo(new Person(),"张三");
GetInfo gets=Person::getName;//person->person.getName();
String str=gets.getInfo(new Person("李四",25));
System.out.println(str);
}
}
interface ShowInfo{
void showInfo(Person person);
}
interface SetInfo{
void setInfo(Person person,String name);
}
interface GetInfo{
String getInfo(Person person);
}
class Person{…………}
