Java基础十九：Lambda表达式的方式启动一个线程，Lambda表达式三要素、省略模式、以及注意事项，Lambda三个小练习

Lambda表达式

1、 Lambda表达式的方式启动一个线程

public class MyRunnable implements Runnable{
   @Override
   public void run() {
       System.out.println("线程启动了！");
   }
}

 

//Lambda基本使用
public class LambdaDemo1 {
   public static void main(String[] args) {
       //第一种方式：启动一个线程
       MyRunnable mr = new MyRunnable();
       Thread t = new Thread(mr);
       t.start();

       //第二种方式：匿名内部类启动一个线程
       new Thread(new MyRunnable(){
           @Override
           public void run() {
               System.out.println("匿名内部类启动一个线程！");
           }
       }).start();

       //第三种方式：lambda表达式启动一个线程
       new Thread(() ->{
           System.out.println("Lambda表达式的方式启动一个线程！");
       }).start();
   }
}

2、Lambda表达式的三要素：形式参数、箭头、表达式

3、Lambda表达式练习1

Lamabda使用前提：有一个接口，有且仅有一个抽象方法

/*练习：
1.定义一个接口(Eatable)，里面定义一个抽象方法：void eat();
2.定义一个测试类(EatableDemo),在测试类中提供两个方法
 一个方法是：useEatable(Eatable e)
 一个方法是主方法，在主方法中调用useEatable方法
* */
public class EatableDemo1 {
   public static void main(String[] args) {
       //第一种：在主方法中调用useEatable方法
          Eatable e = new EatableImpl();
          useEatable(e);
       //第二种：匿名内部类
       useEatable(new Eatable() {
           @Override
           public void eat() {
               System.out.println("这是一个接口实现类2！");
           }
       });
       //第三种:Lambda表达式
       useEatable(()->{
           System.out.println("这是一个接口实现类3！");
       });
   }
   //定义一个方法，把接口作为参数进行传递
   private  static void useEatable(Eatable e){
       e.eat();
   }
}

 

//接口实现类
public class EatableImpl implements Eatable {
   @Override
   public void eat() {
       System.out.println("这是一个接口实现类1！");
   }
}

 

//接口
public interface Eatable {
   void eat();
}

4、Lambda表达式练习2

/*测试类
* 练习2：
1、定义一个接口(Flyable)，里面定义一个抽象方法：void fly(String s);
2、定义一个测试类(FlyableDemo)，在测试类中提供两个方法
  一个方法是：useFlyable(Flyable)
  一个方法是主方法，在主方法中调用useFlyable方法*/
public class FlyableDemo1 {
   public static void main(String[] args) {
       //匿名内部类
       useFlyable(new Flyable() {
           @Override
           public void fly(String s) {
               System.out.println(s);
               System.out.println("匿名内部类自己的方法");
           }
       });

       //Labbda方法
       useFlyable((String s)->{
           System.out.println(s);
           System.out.println("这是Lambda的方法");
       });
   }
   private  static void useFlyable(Flyable f){
       f.fly("这是调用接口中的抽象方法！");
   }
}

 

//接口
public interface Flyable {
   void fly(String s);
}

 

5、Lambda表达式练习3

/*练习3：
1、定义一个接口(Addable)，里面定义一个抽象方法：int add(int x,int y);
2、定义一个测试类(AddableDemo)，在测试类中提供两个方法
  一个方法是：useAddable(Addable a)
  一个方法是主方法，在主方法中调用useAddable方法
*/
public class AddableDemo1 {
   public static void main(String[] args) {
              //Lambda表达式方式
       useAddable((int x,int y)->{
           return x+y;
           //return x-y;
       });
   }
   private  static  void useAddable(Addable a){
       int sum = a.add(10, 20);
       System.out.println(sum);
   }
}

 

//接口
public interface Addable {
   int add(int x,int y);
}

6、Lambda表达式省略模式

/*练习3：
1、如果代码块的语句只有一条，可以省略大括号和分号,如果有return，也可以把return省略

2、有多个参数时，参数类型可以省略不写，但必须全部都不写

*/
public class AddableDemo1 {
   public static void main(String[] args) {
        //Lambda表达式方式：有多个参数时，类型可以省略不写，但必须全部都不写
       useAddable((x,y)->{
           return x+y;
           //return x-y;
       });
       //Lambda省略模式式：如果代码块的语句只有一条，可以省略大括号和分号,如果有return，也可以把return省略
       useAddable((x,y)->x+y);

              //Labbda省略模式1：只有一个参数的情况下，小括号和类型都可以省略
​//useFlyable((String s)->{对比下面一句
​useFlyable((String s)->{
  ​ System.out.println(s);
  ​ System.out.println("这是Lambda的方法");
​});
​//Lambda省略模式2：如果代码块的语句只有一条，可以省略大括号和分号
​useFlyable(s->System.out.println(s));
   }
   private  static  void useAddable(Addable a){
       int sum = a.add(10, 20);
       System.out.println(sum);
   }
}

 

//接口
public interface Flyable {
   void fly(String s);
}

 

//接口
public interface Addable {
   int add(int x,int y);
}

7、Lambda表达注意事项

1. 使用Lambda表达式必须要有接口，并且要求接口中有且仅有一个抽象方法

2. 必须有上下文环境，才能推导出Lambda对应的接口

A. 根据局部变量的赋值得知Lambda对应的接口：Runnabler = () -> System.out.println(“Lambda表达式”);

B. 根据调用方法的参数得知Lambda对应的接口：Rubbabler = () -> System.out.println(“Lambda表达式”).start();

//接口
public interface Inter {
   void show();
}

public class LambdaDemo1 {
   public static void main(String[] args) {
       //第一种：使用Lambda表达式必须要有接口，并且要求接口中有且仅有一个抽象方法
       useInter(() -> System.out.println("好好学习，天天向上！"));
       //第二种：根据调用方法的参数得知Lambda对应的接口
       Runnable r = () -> System.out.println("Lambda表达式1");
       new Thread(r).start();
       //重点第三种：根据调用方法的参数得知Lambda对应的接口
       new Thread(() -> System.out.println("Lambda表达式2")).start();
   }
   private static void useInter(Inter i){
       i.show();
   }
}