lambda

@FunctionalInterface
interface NoReturnMultiParam{
   void method(int a,int b);
}

/**无参无返回值*/
@FunctionalInterface
 interface NoReturnNoParam {
   void method();
}

/**一个参数无返回*/
@FunctionalInterface
 interface NoReturnOneParam {
   void method(int a);
}

/**多个参数有返回值*/
@FunctionalInterface
 interface ReturnMultiParam {
   int method(int a, int b);
}

/*** 无参有返回*/
@FunctionalInterface
 interface ReturnNoParam {
   int method();
}

/**一个参数有返回值*/
@FunctionalInterface
 interface ReturnOneParam {
   int method(int a);
}

//无参无返回
NoReturnNoParam noReturnNoParam=() ->{
   System.out.println("noReturnNoParam");
};
noReturnNoParam.method();

//一个参数无返回
NoReturnOneParam noReturnOneParam=(int a) ->{
   System.out.println("noReturnOneParam  param= " + a);
};
noReturnOneParam.method(6);

//多个参数无返回
NoReturnMultiParam noReturnMultiParam=(int a,int b) ->{
   System.out.println("noReturnMultiParam： a:"+a+",b:"+b);
};
noReturnMultiParam.method(11,4);

//无参有返回值
ReturnNoParam returnNoParam=()->{
   System.out.println("returnNoParam");
   return 14;
};
System.out.println(returnNoParam.method());

//一个参数有返回值
ReturnOneParam returnOneParam=(int a)->{
   System.out.println(" returnOneParam");
   return a;
};
System.out.println(returnOneParam.method(5));

//多个参数有返回值
ReturnMultiParam returnMultiParam=(int a,int b)->{
   System.out.println("returnMultiParam,a:"+a+",b:"+b);
   return a+b;
};
System.out.println(returnMultiParam.method(4,3));

System.out.println("##############################################");
//1.简化参数类型，可以不写参数类型，但是必须所有参数都不写
NoReturnMultiParam noReturnMultiParam1=(a,b)->{
   System.out.println("简化参数类型");
   System.out.println("a:"+a+",b:"+b);
};
noReturnMultiParam1.method(10,6);

//2.简化参数小括号，如果只有一个参数则可以省略参数小括号
NoReturnOneParam noReturnOneParam1=a ->{
   System.out.println("简化小括号");
   System.out.println("a = " + a);
};
noReturnOneParam1.method(7);

//3.简化方法体大括号，如果方法条只有一条语句，则可以胜率方法体大括号
NoReturnNoParam noReturnNoParam1=() -> System.out.println("简化方法体大括号");
noReturnNoParam1.method();

//4.如果方法体只有一条语句，并且是 return 语句，则可以省略方法体大括号
ReturnOneParam returnOneParam1=a-> a+3;
System.out.println(returnOneParam1.method(6));

ReturnMultiParam returnMultiParam1=(a,b) ->a-b;
System.out.println(returnMultiParam1.method(1,4));

System.out.println("#####################################################");

ReturnOneParam returnOneParam2=DecisionRuleColumnEntity::doubleNum;
System.out.println(returnOneParam2.method(3));

DecisionRuleColumnEntity d1=new DecisionRuleColumnEntity();
ReturnOneParam returnOneParam3=d1::addTwo;
System.out.println(returnOneParam3.method(5));

/*Thread t=new Thread(()->{
   for (int i = 0; i < 10; i++) {
      System.out.println("i = " + i);
   }
});
t.start();*/
/*ArrayList<Integer> list = new ArrayList<>();

Collections.addAll(list, 1,2,3,4,5);

//lambda表达式 方法引用
list.forEach(System.out::println);

list.forEach(element -> {
   if (element % 2 == 0) {
      System.out.println(element);
   }
});*/

/**
 * 要求
 * 1.参数数量和类型要与接口中定义的一致
 * 2.返回值类型要与接口中定义的一致
 */
public static int doubleNum(int a) {
   return a * 2;
}

public int addTwo(int a) {
   return a + 2;
}