Java8新特性(三):Lambda表达式和函数式接口结合

220 阅读3分钟

Lambda表达式和函数式接口结合

什么是函数式接口

函数式接口(Functional Interface)就是一个有且仅有一个抽象方法,但是可以有多个非抽象方法的接口。函数式接口可以被隐式转换为 lambda 表达式。

  • 函数接口要在接口上增加 @FunctionalInterface 注解。
  • java8对接口进行了增强,可以拥有static defult等方法,接口的属性默认为public static final
  • 新增的静态方法和默认方法是否会影响其成为一个函数接口呢,并不会,原因是:静态方法和默认方法均为非抽象方法!
  • 完整函数式接口例子如下(可以只要一个有且仅有一个抽象方法):
    @FunctionalInterface
    public interface InterfacePlus {
        //public static final
        String defultValue = null;

        void run();

        @Override
        boolean equals(Object o);

        static Date createDate() {
            return new Date();
        }

        default void sayHello() {
            System.out.println("Hello Java8!");
        }
    }

什么是lambda表达式

Lambda 表达式,也可称为闭包,它是推动 Java 8 发布的最重要新特性。Lambda 允许把函数作为一个方法的参数(函数作为参数传递进方法中。

  • 例子

// 1. 不需要参数,返回值为 5  
() -> 5  

// 2. 接收一个参数(数字类型),返回其2倍的值  
x -> 2 * x  

// 3. 接受2个参数(数字),并返回他们的差值  
(x, y) -> x – y  

// 4. 接收2个int型整数,返回他们的和  
(int x, int y) -> x + y  

// 5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)  
(String s) -> System.out.print(s)

lambda和FunctionalInterface二者结合擦出火花

无参数无返回值函数式接口

/**
 * @Description: 无参无返回值函数式接口
 * @Author: jianweil
 * @date: 2020/12/8 15:19
 */
@FunctionalInterface
public interface InterfaceNoParamNoResult {
    void run();
}

无参有返回值函数式接口

/**
* @Description: 无参有返回值函数式接口
* @Author: jianweil
* @date: 2020/12/8 15:19
*/
@FunctionalInterface
public interface InterfaceNoParamWithResult {
    String run();
}

有参无返回值函数式接口

    
/**
* @Description: 有参无返回值函数式接口
* @Author: jianweil
* @date: 2020/12/8 15:19
*/
@FunctionalInterface
public interface InterfaceWithParamNoResult {
  void run(String s);
}

有参有返回值函数式接口

/**
 * @Description: 有参有返回值函数式接口
 * @Author: jianweil
 * @date: 2020/12/8 15:19
 */
@FunctionalInterface
public interface InterfaceWithParamWithResult {
    String run(Integer integer);
}
            

测试

/**
* @Description: 包含属性为函数式接口的类
*              Lambda表达式和函数式接口结合
* @Author: jianweil
* @date: 2020/12/8 15:20
*/
public class TestLambda {
  /**
   * 无参数无返回
   */
  //匿名内部类
  InterfaceNoParamNoResult param1 = new InterfaceNoParamNoResult() {
      @Override
      public void run() {
          System.out.println("通过匿名内部类实现run()");
      }
  };
  //Lambda表达式 空括号表示无参
  InterfaceNoParamNoResult param = () -> System.out.println("通过Lambda表达式实现run()") ;

  /**
   * 有参数无返回
   */
  InterfaceWithParamNoResult interfaceWithParamNoResult = new InterfaceWithParamNoResult() {
      @Override
      public void run(String s) {
          System.out.println("通过" + s + "实现run(String)");
      }
  };
  InterfaceWithParamNoResult interfaceWithParamNoResult2 = (String s) -> System.out.println("通过" + s + "实现run(String)");


  /**
   * 无参数有返回
   */
  InterfaceNoParamWithResult interfaceNoParamWithResult = new InterfaceNoParamWithResult() {
      @Override
      public String run() {
          return "Hello World!";
      }
  };
  InterfaceNoParamWithResult interfaceNoParamWithResult2 = () -> "Hello Lambda!";

  /**
   * 有参数有返回
   */
  InterfaceWithParamWithResult interfaceWithParamWithResult = new InterfaceWithParamWithResult() {
      @Override
      public String run(Integer integer) {
          return String.valueOf(integer);
      }
  };
  InterfaceWithParamWithResult interfaceWithParamWithResult2 = (Integer integer) -> String.valueOf(integer);



  public static void main(String[] args) {
      System.out.println("---------");
      new TestLambda().param.run();
      new TestLambda().param1.run();
      System.out.println("---------");
      new TestLambda().interfaceWithParamNoResult.run("匿名类");
      new TestLambda().interfaceWithParamNoResult2.run("lambda");
      System.out.println("---------");
      System.out.println(new TestLambda().interfaceNoParamWithResult.run());
      System.out.println(new TestLambda().interfaceNoParamWithResult2.run());
      System.out.println("---------");
      System.out.println(new TestLambda().interfaceWithParamWithResult.run(1));
      System.out.println(new TestLambda().interfaceWithParamWithResult2.run(2));
  }
}

运行结果

---------
通过Lambda表达式实现run()
通过匿名内部类实现run()
---------
通过匿名类实现run(String)
通过lambda实现run(String)
---------
Hello World!
Hello Lambda!
---------
1
2

源码下载

本文章例子源码

Java8新特性系列