Java基础之JDK1.8新特性Lamda

什么是Lamda？

　　Lamda：称为函数式编程，用于代替传统的匿名内部类

　　　　Lamda的语法三种形式：

　　　　　　》 (参数)-> 单行语句;

　　　　　　》 (参数)-> {多行语句};

　　　　　　》 (参数)-> 表达式;

观察传统的匿名内部类：

 1 package test;
 2 /**
 3  * 泛型的使用
 4  * @author Administrator
 5  *
 6  */
 7 public class TestType {
 8 
 9     public static void main(String[] args) {
10         fun(new Msg(){
11             @Override
12             public void show() {
13                 //在传统的匿名内部类中，需要的数据就是这句话
14                 System.out.println("接口中的抽象方法输出信息。。。");
15             }
16         });
17     }
18     /**
19      * 讲接口作为参数，调用接口中的抽象方法
20      * @param msg
21      */
22     public static void fun(Msg msg){
23         msg.show();
24     }
25 }
26 
27 interface Msg{
28     //抽象方法
29     public abstract void show();
30 }

观察函数式编程（Lamda）：无参单行语句

 1 package test;
 2 /**
 3  * 泛型的使用
 4  * @author Administrator
 5  *
 6  */
 7 public class TestType {
 8 
 9     public static void main(String[] args) {
10         //注意这里的  ()-> 表示函数式编程，括号中为空表示无参，代替了匿名内部类的创建
11         fun(()->System.out.println("输出函数式编程信息"));
12     }
13     /**
14      * 讲接口作为参数，调用接口中的抽象方法
15      * @param msg
16      */
17     public static void fun(Msg msg){
18         msg.show();
19     }
20 }
21 
22 interface Msg{
23     //抽象方法
24     public abstract void show();
25 }

　　有参单行语句

 1 package test;
 2 /**
 3  * 泛型的使用
 4  * @author Administrator
 5  *
 6  */
 7 public class TestType {
 8 
 9     public static void main(String[] args) {
10         /**
11          * 注意这里的  (s)-> 定义表达式中需要接收的变量，
12          * 单行语句直接进行输出
13          */
14         fun((s)->System.out.println(s));
15     }
16     /**
17      * 讲接口作为参数，调用接口中的抽象方法
18      * @param msg
19      */
20     public static void fun(Msg msg){
21         msg.show("你好");//设置参数的内容
22     }
23 }
24 
25 interface Msg{
26     //有参的抽象方法
27     public abstract void show(String str);
28 }

　　编写有参多行语句：

 1 package test;
 2 /**
 3  * 泛型的使用
 4  * @author Administrator
 5  *
 6  */
 7 public class TestType {
 8 
 9     public static void main(String[] args) {
10         /**
11          * 注意这里的  (s)-> 定义表达式中需要接收的变量，
12          * 多行语句直接进行输出
13          */
14         fun((s)->{
15             s = s.toUpperCase();//转大写
16             System.out.println(s);
17             s = s.toLowerCase();//转小写
18             System.out.println(s);
19         });
20     }
21     /**
22      * 讲接口作为参数，调用接口中的抽象方法
23      * @param msg
24      */
25     public static void fun(Msg msg){
26         msg.show("Knock coding");//设置参数的内容
27     }
28 }
29 
30 interface Msg{
31     //有参的抽象方法
32     public abstract void show(String str);
33 }

　　编写一个简单的表达式：

 1 package test;
 2 /**
 3  * 泛型的使用
 4  * @author Administrator
 5  *
 6  */
 7 public class TestType {
 8 
 9     public static void main(String[] args) {
10         /**
11          * 注意这里的  (n1,n2)-> 定义表达式中需要接收的变量，
12          * 函数式编程，表达式进行相加计算
13          */
14         fun((n1,n2)->n1+n2);//如果要想写return的话这样子写 fun((n1,n2)->{return n1+n2;});
15     }
16     /**
17      * 讲接口作为参数，调用接口中的抽象方法
18      * @param msg
19      */
20     public static void fun(Msg msg){
21         System.out.println(msg.add(10,20));//设置参数的内容
22     }
23 }
24 
25 interface Msg{
26     //有参的抽象方法
27     public abstract int add(int num1,int num2);
28 }

Lamda表达式（函数式编程）最终解决的问题是：避免了匿名内部类定义过多的无用操作

Java基础之JDK1.8新特性Lamda

猜你喜欢