lambda的语法格式

  • Lambda表达式
  • 语法格式1：无参且无返回值
  • 语法格式2：有一个参数，无返回值
  • 语法格式3：有两个或者两个以上的参数，多条执行语句，有返回值
  • 使用场景
  • 函数式接口


Lambda表达式

语法格式1：无参且无返回值

public interface MyInterface
{
void testMethod();
}
MyInterface m=() ->{System.out.println("卡巴喇嘛");}
  • 注意：->{}中如果只有一句话，那么{}可以省略不写
  • Lambda表达式的本质上就是：接口的实现类的具体的对象

语法格式2：有一个参数，无返回值

public interface MyInterface
{
void testMethod(int num);
}
MyInterface m=x ->{System.out.println("卡巴喇嘛"+x);}
m.testMethod(10);
  • 注意：->{}中如果只有一句话，那么{}可以省略不写
  • 参数的类型可以省略：（num）可以根据接口的定义进行上下文的推断
  • 参数名字 x 是可以随便写的
  • 如果只有一个参数 （）也是可以省略的

语法格式3：有两个或者两个以上的参数，多条执行语句，有返回值

public interface MyInterface
{
  int  testMethod(int num1,int num2);
}
public interface MyInterface 
{
    public abstract int testMethod(int num1,int num2);
}
class Demo3{
    public static void main(String[] args) {
        MyInterface m = (x,y)-> 666;
        System.out.println( m.testMethod(1,2));
    }
}
  • (x,y)有多个参数的话，（）不可以省略
  • 多个执行语句的时候，{}不可以省略
  • 如果只有一句返回值，那么return也可以省略

使用场景

  • Lambda表达式就是能省则省；
  • Lambda表达式的使用场景： 使用 Lamda表达式本质是new一个接口的实现类的具体的对象，但它所依赖的接口是有要求的，这个接口中只能有一个抽象方法。

函数式接口

我们把只有一个抽象方法的接口叫做函数式接口。
一般可以在函数式接口前加入一个注解进行限制：@FunctionalInterface
用了函数式接口，再考虑用Lambda表达式来简化代码

@FunctionalInterface
public interface MyInterface
{
    public abstract int testMethod(int num1,int num2);
}

jdk内置四大函数接口：

  • 消费型接口：Consumer ：void accept(T t)
  • 供给型接口：Supplier ：T get()
  • 函数型接口：Function<T,R> ：appy(T t)
  • 断定型接口（断言型接口）：Predicate :boolean test(T t)
public interface SpendMoney
{
    void buy(double money);
}
class Test
    {
    public static void buySth(double money ,SpendMoney s){
        s.buy(money);
    }
    public static void main(String[] args)
    {
        buySth(4000, new SpendMoney()
        {
            @Override
            public void buy(double money)
            {
                System.out.println(money);
            }
        });
    }
}

利用内置接口改造

import java.util.function.Consumer;
//public interface SpendMoney
//{
//    void buy(double money);
//}
class Test
    {
    public static void buySth(double money , Consumer s){
        s.accept(money);
    }
    public static void main(String[] args)
    {
        buySth(4000, new Consumer<Double>()//泛型必须在创建对象的时候确定
        { 
            public void accept(Double money)
            {
                System.out.println(money);
            }
        });
    }
}
import java.util.function.Consumer;

//public interface SpendMoney
//{
//    void buy(double money);
//}
class Test
    {
    public static void buySth(double money , Consumer s){
        s.accept(money);
    }
    public static void main(String[] args)
    {
        buySth(4000, new Consumer<Double>()//泛型必须在创建对象的时候确定
        {
            public void accept(Double money)
            {```
                System.out.println(money);
            }
        });
        //->用Lambda表达式改造后如下所示
        buySth(4000,m -> System.out.println(m)  );

    }
}