函数式接口

任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口。对于函数式接口，可以通过lambda表达式来创建该接口的对象。

lambda表达式的推导

1. 正常实现


//1. 首先定义一个函数式接口
interface LambdaInterface{ void lambda(); }
//2. 实现类
class LambdaImpl implements LambdaInterface{
  public void lambda(){
    System.out.println("lambda test");
  }
}
//3. 一般实现
public class TestLambda{
  //main函数
  public static void main(String[] args){
    //创建一个新对象，
    LambdaImpl lambda = new LambdaImpl();
    lambda.lambda();
  }
}

2. 静态内部类实现

将单独的实现类添加到Test类中，作为静态内部类，少定义了一个外部类

//1. 定义一个函数式接口
interface LambdaInterface { void lambda(); }
//2. 使用静态内部类实现
public class TestLambda {
  //实现类作为静态内部类
  static class LambdaImpl implements LambdaInterface {
    public void lambda() {
      System.out.println("lambda test!!");
    }
  }

  public static void main(String[] args) {
      new LmabdaImpl().lambda();
  }
}

3. 通过局部内部类实现

将静态内部类进一步简化为局部内部类

//1. 定义一个函数式接口
interface LambdaInterface { void lambda(); }
//2. 使用局部内部类实现
public class TestLambda{
  public static void main(String[] args) {
    //2.实现类作为局部内部类
    class LambdaImpl implements LambdaInterface{
      public void lambda(){ System.out.println("lambda test!!");}
    }
  }
  new LambdaImpl().lambda();
}

4. 通过匿名内部类实现

实现类是不需要类名的，只要实现方法即可，这里将其作为匿名内部类，进行类名的简化

//1. 定义一个函数式接口
interface LambdaInterface { void lambda(); }
//2. 使用匿名内部类实现
public class TestLambda{
  public static void main(String[] args){
    //直接在匿名内部类中实现LambdaInterface接口
    LambdaTest lambda = new LambdaInterface(){
      public void lambda(){
        System.out.println("lambda test!!");}
    }
    lambda.lambda();//父类引用指向子类实例，多态
  }
}

5. lambda简化

由于接口式函数中只有一个方法，即使通过匿名内部类实现，也必须指定方法名，这是没有意义的。因此在lambda表达式中，将默认的类名和方法名省略掉

//1. 定义一个函数式接口
interface LambdaInterface { void lambda(); }
//2. 使用lambda表达式实现
public class TestLambda{
  public static void main(String[] args){
    //将指定类名和方法名的过程全部省略，直接使用()->{}代替
    LambdaTest lambda = ()->{ System.out.println("lambda test!!");}
    lambda.lambda();//父类引用指向子类实例，多态
  }
}

6. 带有参数的lambda表达式

lambda表达式是可以带有参数的：

//1. 定义一个带有参数的函数式接口
interface KeyBoard{void type(Character c);}
//2. 使用lambda表达式实现
public class Test2{
  public static void main(String[] args){
    KeyBoard keyBoard = (Character c) -> {
      System.out.println(c + " was pressed");
    };
    keyBoard.type('a');
  }
}

6.1 简化参数类型

由于函数式接口只有一个方法，不存在重载的情况，因此参数列表式固定的，可以省略参数的类型：

//1. 定义一个带有参数的函数式接口
interface KeyBoard{void type(Character c);}
//2. 使用lambda表达式实现
public class Test2{
  public static void main(String[] args){
    KeyBoard keyBoard = (c) -> {  //省略了参数的类型
      System.out.println(c + " was pressed");
    };
    keyBoard.type('a');
  }
}

6.2 省略小括号

当lambda表达式只有一个参数的时候，连包裹参数列表的小括号也是可以省略的：

//1. 定义一个带有参数的函数式接口
interface KeyBoard{void type(Character c);}
//2. 使用lambda表达式实现
public class Test2{
  public static void main(String[] args){
    KeyBoard keyBoard = c -> {
      System.out.println(c + " was pressed");
    };
    keyBoard.type('a');
  }
}

6.3 省略花括号

当lambda表达式实现的方法只有一条语句的时候，甚至还可以省略包裹方法体的花括号：

//1. 定义一个带有参数的函数式接口
interface KeyBoard{void type(Character c);}
//2. 使用lambda表达式实现
public class Test2{
  public static void main(String[] args){
    KeyBoard keyBoard = c -> System.out.println(c + " was pressed");
    keyBoard.type('a');
  }
}

希望可以帮到你，还有未来的我


【大中小】【打印】【繁体】【投稿】【收藏】【推荐】【举报】【评论】【关闭】【返回顶部】

上一篇：初步探索GraalVM——云原生时代JV..	下一篇：day04-SpringCloud Eureka-服务注..