Java的lambda语法格式及函数式接口

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)  );

    }
}