多线程：lambda表达式

1.lambda表达式

lambda表达式是jdk1.8中出现的，其作用有：

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

• 代码简洁

• 减少冗余代码

理解Functional interface(函数式接口)是学习lambda关键所在

函数接口的定义：

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

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

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

public class TestLambda1 {
    //静态内部类
    static class Like2 implements Ilike{
        @Override
        public void lambda() {
            System.out.println("i like lambda2");
        }   
    }   
    public static void main(String[] args) {
        
        //局部内部类
         class Like3 implements Ilike{
            @Override
            public void lambda() {
                System.out.println("i like lambda3");           
            }       
        }        
        //匿名内部类     
        Ilike like = new Like();
        like.lambda();
        
        like = new Like2();
        like.lambda();
        
        like = new Like3();
        like.lambda();
        
        //匿名内部类，没有类的名称，需要借助接口或者父类来实现
        like = new Ilike() {
            @Override
            public void lambda() {
                System.out.println("i like lambda4");
            }           
        };
        like.lambda();
        
        //lambda简化
        like = ()->{
            System.out.println("i like lambda5");
        };
        like.lambda();
    }
}
//定义一个接口
interface Ilike{
    void lambda();
}
//实现类
class Like implements Ilike{
    @Override
    public void lambda() {
        System.out.println("i like lambda1");
    }   
}

对lambda表达式进行简化：

public class TestLambda2 {
    static class love2 implements Ilove{
        @Override
        public void love(int i) {
            System.out.println("我喜欢你2---->"+i);
        }       
    }
    public static void main(String[] args) {
        Ilove l = new love1();
        l.love(11);
        
        l = new love2();
        l.love(22);
        
        class love3 implements Ilove{
            @Override
            public void love(int i) {
                System.out.println("我喜欢你3---->"+i); 
            }
        }
        l = new love3();
        l.love(33);
​
        
        l = new Ilove() {
​
            @Override
            public void love(int i) {
                System.out.println("我喜欢你4---->"+i);                 
            }           
        };
        l.love(44);
        
        //简化1，去除参数类型
//      l = (i)->{
//          System.out.println("我喜欢你5---->"+i);     
//      };
        
        //简化2，去除括号(只能有一个参数才能去除)
        l = i->{
            System.out.println("我喜欢你5---->"+i); 
        };
        //简化3，去除大括号（只有一行代码才能去除大括号）
        l = i->System.out.println("我喜欢你5---->"+i);  ;
        
        l.love(55);
    }
}
interface Ilove{
    void love(int i);
}
class love1 implements Ilove{
    @Override
    public void love(int i) {
        System.out.println("我喜欢你1---->"+i);
    }
}