Java-----多线程【Lambda表达式】

Lambda表达式

• λ希腊字母表中排序第十一位的字母，英语名称为Lambda

• 避免匿名内部类定义过多

• 其实质属于函数式编程的概念

  (params) -> expression[表达式]

  (params) -> statement[语句]

  ​ (params) -> {statements}

• a -> System.out.println(“i like lambda——>”+a);

  new Thread(()->System.out.println("多线程学习")).start();
  

• 为什么要使用lambda表达式

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

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

• 理解Functional Interface(函数式接口) 是学习Java8 lambda表达式的关键所在。

• 函数式接口的定义:

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

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

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

• 实例：

  public class TextLambda {
       
  
      // 3.静态内部类
       static class lamtext1 implements lam{
       
  
          @Override
          public void lamtext1() {
       
              System.out.println("lamdba----------2");
          }
      }
  
      public static void main(String[] args) {
       
          // 普通调用
          lamtext l = new lamtext();
          l.lamtext1();
  
          // 调用静态内部类
          lamtext1 l2 = new lamtext1();
          l2.lamtext1();
  
          // 4.局部内部类
          class lamtext2 implements lam{
       
  
              @Override
              public void lamtext1() {
       
                  System.out.println("lamdba----------3");
              }
          }
          lamtext2 l1 =new lamtext2();
          l1.lamtext1();
  
          // 5.匿名内部类，没有类名，必须借助接口或父类
          lam ll =new lam() {
       
              @Override
              public void lamtext1() {
       
                  System.out.println("lamdba----------4");
              }
          };
          ll.lamtext1();
  
          // lambda表达式简化
          ll = ()->{
       
              System.out.println("lamdba----------5");
          };
          ll.lamtext1();
  
      }
  
  }
  
  // 1.定义一个函数式接口
  interface lam{
       
      void lamtext1();
  }
  
  // 2.实现类
  class lamtext implements lam{
       
  
      @Override
      public void lamtext1() {
       
          System.out.println("lamdba----------1");
      }
  }
  

• 实例2：

  public class TextLambda_yc {
       
  
      static class text1 implements lam1{
       
  
          @Override
          public void textlam(int a, String b) {
       
              System.out.println(b+"："+a);
          }
      }
  
      public static void main(String[] args) {
       
          lam1 l = new text();
          l.textlam(1,"静态内部类");
  
          class text2 implements lam1{
       
  
              @Override
              public void textlam(int a, String b) {
       
                  System.out.println(b+"："+a);
              }
          }
          l = new text2();
          l.textlam(2,"局部内部类");
  
          l = new lam1() {
       
              @Override
              public void textlam(int a, String b) {
       
                  System.out.println(b+"："+a);
              }
          };
          l.textlam(3,"匿名内部类");
  
          l=(a,b)->{
       
              System.out.println(b+"："+a);
          };
          l.textlam(4,"lambda表达式");
  
      }
  }
  
  interface lam1{
       
      void textlam(int a,String b);
  }
  
  class text implements lam1{
       
  
      @Override
      public void textlam(int a, String b) {
       
          System.out.println(b+"："+a);
      }
  }
  
  /*
  * 总结：
  * lambda表达式只能有一行代码的情况下才能简化成为一行，如果有多行，那么就用代码块包裹
  * 前提是接口为函数式接口
  * 多个参数也可以去掉参数类型，要去掉都去掉，必须加括号
  * */