Java函数式编程

匿名内置类

使用场景

Java作为一门面向对象的静态语言，其封装性能够屏蔽数据结构的细节，从而更加关注模块（功能）的功能性。其静态性也确保了Java强类型的特性。随着模块功能的提升，伴随而来的是复杂度的增加，代码的语义清晰依赖于开发人员的抽象(通用)和命名类或方法能力。尽管编程思想和设计模式能够促使编程风格趋于统一，然而大多数业务系统属于面向过程的方式(增删改查，输入输出)，这与面向对象编程在一定程度上存在一些冲突。Java编程语言为了解决这个问题，引入了匿名内置类的方案

经典使用场景
- Java Event/Listener
- Java Concurrent
- Spring Template

基本特征

无名称类

声明位置（执行模块）：

static block

  // Static 块
  static {
      new Runnable() {
          @Override
          public void run() {
          }
      };
  }

实例block

  
  // 实例块
  {
      new Callable() {
          @Override
          public Object call() throws Exception {
              return null;
          }
      };
  }

方法

  
  // 方法（类或实例）
  PropertyChangeListener listener = new       PropertyChangeListener() {
      @Override
      public void propertyChange(PropertyChangeEvent evt) {
      }
  };

构造器

  // 构造器
  public InnerClassDemo() {
      new Comparable(){
  
          @Override
          public int compareTo(Object o) {
              return 0;
          }
      };
  }

并非特殊的类结构

类全名称：$${package}.${declared_class}.${num}

基本特点

基于多态(多数基于接口编程) 如Runnable,Callable
实现类无需名称
允许多个抽象方法

  
  new KeyListener(){
      @Override
      public void keyTyped(KeyEvent e) {
      }
      @Override
      public void keyPressed(KeyEvent e) {
      }
      @Override
      public void keyReleased(KeyEvent e) {
      }
  };

编程局限

代码臃肿强制型约束如：Runnable，Callable都指定了一类型
接口方法升级

Lambda表达式

基本特点

流程编排清晰
函数类型编程
改善代码臃肿兼容接口升级

实现手段

@FunctionalInterface接口声明函数式接口，并不一定要打这个注解，只要满足约束它就是函数式接口，有且只有一个抽象方法

Lambda语法

  
  // 匿名类 传统写法
  PropertyChangeListener listener = new PropertyChangeListener() {
      @Override
      public void propertyChange(PropertyChangeEvent evt) {
          println(evt);
      }
  };
  
  // Lambda 基本写法
  PropertyChangeListener listener2 = evt -> {
      println(evt);
  };

方法引用

  
  // Lambda 简略写法
  // PropertyChangeListener#propertyChange(PropertyChangeEvent)
  // 属于有入参，没有返回，与 println(Object) 一样
  PropertyChangeListener listener3 = LambdaDemo::println;

四种模式

SCFP = Supplier + Consumer + Function + Predicate

  
  public class LambdaDemo {
      // SCFP = Supplier + Consumer + Function + Predicate
      // 四种模式（缺少 Action 模式）
      // Action 模式
      private static void showAction() {
          Runnable runnable = new Runnable() {
              @Override
              public void run() {
              }
          };
          Runnable runnable2 = () -> {
          };
          Runnable runnable3 = LambdaDemo::showConsumer;
      }
      // Supplier 模式
      private static void showSupplier() {
          String string = "Hello,World";
          Supplier<String> string2 = () -> "Hello,World";
          Supplier<String> string3 = () -> new Integer(2).toString();
      }
      // Consumer 模式
      private static void showConsumer() {
          // 匿名类 传统写法
          PropertyChangeListener listener = new PropertyChangeListener() {
              @Override
              public void propertyChange(PropertyChangeEvent evt) {
                  println(evt);
              }
          };
  
          // Lambda 基本写法
          PropertyChangeListener listener2 = evt -> {
              println(evt);
          };
  
          // Lambda 简略写法
          // PropertyChangeListener#propertyChange(PropertyChangeEvent)
          // 属于有入参，没有返回，与 println(Object) 一样
          PropertyChangeListener listener3 = LambdaDemo::println;
      }
  
      // Function 模式
      private static void showFunction() {
          Function<String, Integer> f = LambdaDemo::compareTo;
      }
  
      private static Integer compareTo(String value) {
          return value.compareTo("Hello,World");
      }
      public static void main(String[] args) {
          Action a = () -> {
          };
      }
      private static void println(Object object) {
          System.out.println(object);
      }
      @FunctionalInterface
      public interface Action {
          void execute();
          default void doExecute() {
              execute();
          }
      }
      private static void stream() {
          Stream.of(1, 2, 3, 4, 5)
                  .map(String::valueOf)
          ;
      }
  }

编程局限

单一抽象方法

Lambda调试困难

Stream API 操作能力有限