Lambda表达式

Lamda表达式

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

• 起始质属于函数式编程的概念

  • （params） -> expression[表达式]

  • （params） -> statements[语句]

  • （params） -> {statements}

a -> System.out.println("i like lambda --->" + a);

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

 

• 为什么要使用 lambda 表达式

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

  • 可以让你的代码看起来很简洁

  • 去掉了一堆没有意义的代码，只留下和信的逻辑

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

• 函数式接口的定义

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

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

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

 

推导 lambda 表达式

 package com.kuang.Lambda;
 ​
 /*
 * 推导lambda表达式
 * */
 ​
 public class TestLambda {
 ​
     //3.静态内部类
     static class Like2 implements ILike{
         @Override
         public void like() {
             System.out.println("i like lambda2");
         }
     }
 ​
     public static void main(String[] args) {
         
         ILike iLike = new Like();
         iLike.like();
 ​
         iLike = new Like2();
         iLike.like();
 ​
         //4.局部内部类
         class Like3 implements ILike{
             @Override
             public void like() {
                 System.out.println("i like lambda3");
             }
         }
 ​
         iLike = new Like3();
         iLike.like();
 ​
         //5.匿名内部类,没有类的名称，必须借助接口或者父类
         iLike = new ILike(){
             @Override
             public void like() {
                 System.out.println("i like lambda4");
             }
         };
         iLike.like();
 ​
         //6.用lambda简化
         iLike = ()->{
             //System.out.println("i like lambda5");
         };
         iLike.like();
 ​
     }
 }
 ​
 //1.定义一个函数式接口
 interface ILike{
     void like();
 }
 ​
 //2.实现类
 class Like implements ILike{
     @Override
     public void like() {
         System.out.println("i like lambda");
     }
 }

 

lambda 表达式的简化

 package com.kuang.Lambda;
 ​
 public class TestLambda2 {
 ​
     public static void main(String[] args) {
         Love love = null;
         ILoveY iLoveY = new ILoveY();
 ​
         //简化1：
         love = (int a)->{
             System.out.println("爱你"+a+"遍");
         };
         love.love(3000);
         //简化2：
         love = a ->{
             System.out.println("爱你"+a+"遍");
         };
         love.love(3000);
         //简化3：
         love = a -> System.out.println("爱你"+a+"遍");
         love.love(3000);
         /*
         * 总结：
         * 1.lambda表达式只能在只有一行代码的情况下才能简化成一行，如果有多行，那么必须用代码块来包裹{}
         * 2.使用lambda表达式的前提是接口为函数式接口（即接口里只有一个函数）
         * 3.含有多个参数也可以去掉参数类型，要去掉就都去掉，但是必须加上括号
         * */
 ​
     }
 ​
 }
 ​
 interface Love{
     void love(int a);
 }
 ​
 class ILoveY implements Love{
 ​
     @Override
     public void love(int a) {
 ​
     }
 }
 ​