避免匿名内部类定义过多
是函数式编程的概念

  1. package com.kai.lesson2;
  3. //推导lambda表达式
  5. public class TestLambda1 {
  8.     //3.静态内部类
  9.     static class Like2 implements ILike{
  10.         @Override
  11.         public void lambda() {
  12.             System.out.println("i like lambda2");
  13.         }
  14.     }
  16.     public static void main(String[] args) {
  17.         ILike like=new Like();
  18.         like.lambda();
  20.         like=new Like2();
  21.         like.lambda();
  23.         //4.局部内部类
  24.         class Like3 implements ILike{
  25.             @Override
  26.             public void lambda() {
  27.                 System.out.println("i like lambda3");
  28.             }
  29.         }
  31.         like=new Like3();
  32.         like.lambda();
  34.         //5.匿名内部类，没有类的名称，必须借助接口或者父类
  35.         like=new Like(){
  36.             @Override
  37.             public void lambda() {
  38.                 System.out.println("i like lambda4");
  39.             }
  41.         };
  42.         like.lambda();
  44.         //6.用lambda简化
  45.         like = () ->{
  46.                 System.out.println("i like lambda5");
  47.             };
  48.         like.lambda();
  51.     }
  52. }
  54. //1.定义一个函数式接口
  55. interface ILike{
  56.     void lambda();
  57. }
  59. //2.实现类
  60. class Like implements ILike{
  61.     @Override
  62.     public void lambda() {
  63.         System.out.println("i like lambda");
  64.     }
  65. }

例子

  1. package com.kai.lesson2;
  3. public class TestLambda2 {
  5.     static class Love2 implements ILove{
  6.         @Override
  7.         public void love(int a) {
  8.             System.out.println("I Lobe U"+a);
  9.         }
  10.     }
  14.     public static void main(String[] args) {
  15.         ILove love= new Love();
  16.         love.love(1);
  18.         love=new Love2();
  19.         love.love(2);
  21.         class Love3 implements ILove{
  22.             @Override
  23.             public void love(int a) {
  24.                 System.out.println("I Lobe U"+a);
  25.             }
  26.         }
  27.         love=new Love3();
  28.         love.love(3);
  31.         love=new Love(){
  32.             @Override
  33.             public void love(int a) {
  34.                 super.love(a);
  35.             }
  36.         };
  37.         love.love(4);
  39.         love=(int a)->{
  40.             System.out.println("I Lobe U"+a);
  42.         };
  43.         love.love(5);
  45.         //简化
  46.         love=a->{
  47.             System.out.println("I Lobe U"+a);
  49.         };
  50.         love.love(6);
  53.     }
  54. }
  57. interface ILove{
  58.     void love(int a);
  59. }
  61. class Love implements ILove{
  62.     @Override
  63.     public void love(int a) {
  64.         System.out.println("I Lobe U"+a);
  65.     }
  66. }
  1. lambda表达式只能有一行代码的情况下才能简化为1行，否则要用{}包裹
  2. 必须是函数式接口
  3. 多个参数也可以去掉参数类型，要去掉都去掉