一、 Lambda表达式使用

1、 Lambda格式

(形式参数) -> {代码块}

形式参数：
有多个的时候逗号隔开；没有参数为空
-> :
英文，中画线、大于符号组成，固定写法。指向代码块;
代码块：
事务逻辑

2、演示demo：线程启动，底下分别是三种实现方式

实现Runnable接口
匿名内部类
lambda表达式

// 1. 实现Runnable接口
public class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("线程启动啦~");
    }
}
public class Test {
    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable);
        thread.start();
    }
}

// 方法2：匿名内部类方式调用
public class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("线程启动啦~");
    }
}

public class Test {
    public static void main(String[] args) {
        Thread thread2 = new Thread(new MyRunnable());
        thread2.start();
         }
}

 // 方法3：lambda表达式方式实现
public class Test {
    public static void main(String[] args) {
        Thread thread3 = new Thread(() -> {
            System.out.println("lamda表达式启动线程");
        });
        thread3.start();
    }
}

3、 Lambda使用的前提

接口
接口有且只有一个抽象方法

如下：

4、Lambda表达式的几种类型

// 1.无参无返回值
public interface MyInterface {
    public abstract void show();
}

public class MyInterfaceTest {
    public static void test(MyInterface myInterface) {
        myInterface.show();
    }

    public static void main(String[] args) {
        MyInterface myInterface = () -> {
            System.out.println("lambda表达式实现show方法");
        };
        test(myInterface);
    }

}

// 2. 有参无返回值
// 1) 有一个参数无返回值
public interface MyInterface2 {
    void eat(String food);
}
public class MyInterfaceTest {
    public static void eat(MyInterface2 myInterface2) {
        myInterface2.eat("鸡蛋");
    }

    public static void main(String[] args) {
      MyInterface2 myInterface2 = (String food) -> {
            System.out.println("这是一个带参无返回值的lambda表达式");
            System.out.println("今天我吃了"+food);
        };
      eat(myInterface2);
        }
   // 2) 多个参数，无返回值
   public interface SumInterface {
    void add(int a, int b);
}
   public class MyInterfaceTest {
     public static void add(SumInterface sumInterface, int a, int b) {
       sumInterface.add(a, b);
     }
   public static void main(String[] args) {
     SumInterface sumInterface = (int a, int b) -> {
       System.out.println("a + b = " + (a + b));
       };
       add(sumInterface, 3, 4);
    }
}

// 3. 多个参数，有返回值
public interface SubInterface {
    int sub(int a,int b);
}
public static void sub(SubInterface subInterface, int a, int b) {
  subInterface.sub(a,b);
  }
public static void main(String[] args) {
   SubInterface subInterface = (int a, int b) -> {
      int i = a - b;
      System.out.println("a - b = " + i);
      return i;
      };
   sub(subInterface,5,2);

二、省略模式

1、几种可以省略的场景

参数类型可以省略
多个参数不能只省略一个
如果参数类型有且只有一个，则小括号可以省略
若代码块只有一句，可省略大括号，分号
如果有return，则return也要省略掉

// 参数类型可以省略
public interface SubInterface {
    int sub(int a,int b);
}
public static void sub(SubInterface subInterface, int a, int b) {
  subInterface.sub(a,b);
  }
public static void main(String[] args) {
   SubInterface subInterface = (a,b) -> {
      int i = a - b;
      System.out.println("a - b = " + i);
      return i;
      };
   sub(subInterface,5,2);

        // 如果参数类型有且只有一个，则小括号可以省略
//        MyInterface2 myInterface2 = (String food) -> {
//            System.out.println("这是一个带参无返回值的lambda表达式");
//            System.out.println("今天我吃了" + food);
//        };
        MyInterface2 myInterface2 = food -> {
            System.out.println("这是一个带参无返回值的lambda表达式");
            System.out.println("今天我吃了" + food);
        };
        eat(myInterface2);

//        MyInterface myInterface = () -> {
//            System.out.println("lambda表达式实现show方法");
//        };
        // 若代码块只有一句，可省略大括号，分号
        MyInterface myInterface = () ->
                System.out.println("lambda表达式实现show方法");