Lambda 表达式

初识Lambda表达式：

• 希腊字母表中排序第十一位的字母，英语名称为 Lambda
• 避免匿名内部类定义过多
• 其实质属于函数式编程的概念

为什么要使用lambda表达式：

• 避免匿名内部类定义过多
• 可以让你的代码看起来更加简捷
• 去掉了一堆没有意义的代码，只留下核心的逻辑

也许你会说，我看了Lamdba表达式，不但不觉得简洁，反而觉得更乱了，看不懂了，那是因为我们还没有习惯，用的多了，看的习惯了，就好了

• 理解Functional interface（函数式接口）是学习Java8 lambda表达式的关键所在。

• 函数式接口的定义：

  • 任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口

    public interface Runnable{
             
        public abstract void run();
    }
    

  • 对于函数式接口，我们可以通过lambda 表达式来创建接口对象。

• Lambda案例 一步一步简化

  package Thread;
  
  // 推导Lambda表达式
  public class TestLambda {
         
  
      //静态内部类
      static class like2 implements  Ilike{
         
          @Override
          public void lambda() {
         
              System.out.println("I like lambda2 我是静态内部类");
          }
      }
  
  
      public static void main(String[] args) {
         
          Ilike i=new like();
          i.lambda();
  
          i=new like2();
          i.lambda();
  
          //局部内部类
          class like3 implements  Ilike{
         
  
              @Override
              public void lambda() {
         
                  System.out.println("I like lambda3 我是局部内部类");
              }
          }
  
          i=new like3();
          i.lambda();
  
          //匿名内部类  匿名内部类需要借助 接口或者父类
          i=new Ilike() {
         
              @Override
              public void lambda() {
         
                  System.out.println("I like lambda4 我是匿名内部类");
              }
          };
  
          i.lambda();
  
          //Lambda 简化 
          i =()->{
         
              System.out.println("I like lambda5 我是Lambda");
          };
          i.lambda();
  
      }
  
  
  
  }
  
  
  //1.定义一个函数式接口
  interface Ilike{
         
      void lambda();
  }
  
  class like implements  Ilike{
         
  
      @Override
      public void lambda() {
         
          System.out.println("I like lambda 我是普通类");
      }
  }
  

• 案例2： lambda的进一步简化

  package Thread;
  
  import java.sql.SQLOutput;
  
  public class TestLambda1 {
         
  
      //静态内部类
      static  class ggx implements sleep{
         
          @Override
          public void sleep(int a) {
         
              System.out.println("我睡了"+a+"个小时");
          }
      }
  
      public static void main(String[] args) {
         
          sleep t=new wwl();
          t.sleep(2);
  
          //调用静态内部类
          t=new ggx();
          t.sleep(3);
  
          //局部内部类
          class zq implements sleep{
         
              @Override
              public void sleep(int a) {
         
                  System.out.println("我睡了"+a+"个小时");
              }
          }
          //调用局部内部类
          t=new zq();
          t.sleep(4);
  
          //匿名内部类
          t=new sleep() {
         
              @Override
              public void sleep(int a) {
         
                  System.out.println("我睡了"+a+"个小时");
              }
          };
          t.sleep(8);
  
          //Lambda 简化1 参数类型
  //        t =(a)->{
         
  //            System.out.println("我睡了"+a+"个小时");
  //        };
  
          //Lambda 简化2 简化括号
  //        t= a->{
         
  //            System.out.println("我睡了"+a+"个小时");
  //        };
  
          //Lambda 简化3  去掉花括号
          t = a-> System.out.println("我睡了"+a+"个小时");
  
     
          t.sleep(9);
      }
  }
  
  
  interface  sleep{
         
      void sleep(int a);
  }
  
  class wwl implements sleep{
         
      @Override
      public void sleep(int a) {
         
          System.out.println("我睡了"+a+"个小时");
      }
  }
  

​

总结：

• lambda表达式只能有一行代码的情况下才能简化成为一行，如果有多行，那么就用代码块包裹。
• 前提是接口为函数接口
• 多个参数也可以去掉参数类型，要去掉都去掉，但是必须要加上括号