Java多线程（六）lamda表达式

拼搏现实的明天。 2022-11-06 14:52 7阅读 0赞

## 前言 ##

**lamda表达式只支持函数式接口。**

*  Lambda 表达式是 JDK8 的一个新特性，可以取代大部分的匿名内部类，写出更优雅的 Java 代码，尤其在集合的遍历和其他集合操作中，可以极大地优化代码结构。
 *  为啥要突然插播一个lamda表达式的学习，因为这玩意很有逼格呀~代码写起来更有大佬的感觉。

##### 一、函数式接口 #####

*  什么是函数式接口？
    
     *  任何一个接口，**有且只有** 一个抽象方法，那么它就是函数式接口。
 *  典型的函数式接口

public interface mainInterface { 
        void funMethod();
    }

*  **对于函数式接口，我们可以用lamda表达式来创建他的实现对象。**

##### 二、接口的五种实现方式 #####

*  ①正常类实现  
    代码案例：

/** * 1.正常接口实现类 */
    class FunInterImpl implements FunInter{ 
        //重写该方法
        @Override
        public void method(String name) { 
            System.out.println("我是实现类中的重写方法："+name);
        }
    }

*  ②静态内部类实现

//2、静态内部类实现
        static class FunInterImpl implements FunInter{ 
            @Override
            public void method(String name) { 
                System.out.println("我是实现类中的重写方法："+name);
            }
        }

*  ③局部内部类实现

//3.局部内部类
            class FunInterImpl2 implements FunInter{ 
                @Override
                public void method(String name) { 
                    System.out.println("我是实现类中的重写方法："+name);
                }
            }

*  ④匿名内部类实现

//4.匿名内部类,要一分号;结尾
            FunInter funInter2 = new FunInter() { 
                @Override
                public void method(String name) { 
                    System.out.println("我是实现类中的重写方法："+name);
                }
            };

*  ⑤lamda表达式实现

//5.lamda表达式实现
            FunInter funInter3 = (String name) ->{ 
                System.out.println("我是实现类中的重写方法："+name);
            };

*  整体代码：

public class NoReturnMultiParam { 
        public static void main(String[] args) { 
            //1.正常实现接口的方式
            FunInterImpl funInter = new FunInterImpl();
            funInter.method("1、实现类");
            System.out.println("***************************************");
            //2、静态内部类实现
            FunInterImpl funInter1 = new FunInterImpl();
            funInter.method("2、静态内部类");
            System.out.println("***************************************");
            //3.局部内部类
            class FunInterImpl2 implements FunInter{ 
                @Override
                public void method(String name) { 
                    System.out.println("我是实现类中的重写方法："+name);
                }
            }
            FunInterImpl2 funInterImpl2 = new FunInterImpl2();
            funInterImpl2.method("3、局部内部类");
            System.out.println("***************************************");
            //4.匿名内部类,要一分号;结尾
            FunInter funInter2 = new FunInter() { 
                @Override
                public void method(String name) { 
                    System.out.println("我是实现类中的重写方法："+name);
                }
            };
            funInter2.method("4、匿名内部类");
            System.out.println("***************************************");
            //5.lamda表达式实现
            FunInter funInter3 = (String name) ->{ 
                System.out.println("我是实现类中的重写方法："+name);
            };
            funInter3.method("5.lamda表达式实现");
        }
    
        //2、静态内部类实现
        static class FunInterImpl implements FunInter{ 
            @Override
            public void method(String name) { 
                System.out.println("我是实现类中的重写方法："+name);
            }
        }
    }
    
    /** * 这个注解是用来标注函数式接口的 * 1.必须注解在接口上 * 2.被注解的接口有且只有一个抽象方法 * 3.被注解的接口可以有默认方法/静态方法，或者重写Object的方法 */
    @FunctionalInterface
    interface FunInter{ 
        void method(String name);
    }
    
    /** * 1.正常接口实现类 */
    class FunInterImpl implements FunInter{ 
    
        //重写该方法
        @Override
        public void method(String name) { 
            System.out.println("我是实现类中的重写方法："+name);
        }
    }

*  执行结果如下：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyOTQ0Mw_size_16_color_FFFFFF_t_70]

##### 二、lamda表达式 #####

*  实现方式：

public class lamdaTest01 { 
        public static void main(String[] args) { 
    
            /** * 多参数无返回 */
            NoReturnMultiParam1 n1 = (int a,int b) ->{ 
                System.out.println("多参数无返回:"+a+b);
            };
            n1.method(1,2);
    
            /** * 无参无返回值 */
            NoReturnNoParam n2 = ()->{ 
                System.out.println("无参无返回值");
            } ;
            n2.method();
    
            /** * 一个参数无返回 */
            NoReturnOneParam n3 = (int a) -> { 
                System.out.println("一个参数无返回" + a);
            };
            n3.method(11);
    
            /** * 多个参数有返回值 */
            ReturnMultiParam n4 = (int a,int b)->{ 
                System.out.println("多个参数有返回值" + a);
                return 1;
            };
            System.out.print("****"+n4.method(1, 3));
    
            /** * 无参有返回 */
             ReturnNoParam n5 = ()->{ 
                 System.out.println("无参有返回");
                 return 1;
             };
            System.out.print("***"+n5.method());
    
            /** * 一个参数有返回值 */
            ReturnOneParam n6 = (int a) ->{ 
                System.out.println("一个参数有返回值"+a);
                return a;
            };
            System.out.print("***"+n6.method(1));
        }
    }
    
    /**多参数无返回*/
    @FunctionalInterface
    interface NoReturnMultiParam1 { 
        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);
    }

执行结果如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyOTQ0Mw_size_16_color_FFFFFF_t_70 1]

##### 三、lamda表达式的简化： #####

*  简化的方式：

//1.简化参数类型，可以不写参数类型，但是必须所有参数都不写
            NoReturnMultiParam1 lamdba1 = (a, b) -> { 
                System.out.println("简化参数类型");
            };
            lamdba1.method(1, 2);
    
            //2.简化参数小括号，如果只有一个参数则可以省略参数小括号
            NoReturnOneParam lambda2 = a -> { 
                System.out.println("简化参数小括号");
            };
            lambda2.method(1);
    
            //3.简化方法体大括号，如果方法条只有一条语句，则可以胜率方法体大括号
            NoReturnNoParam lambda3 = () -> System.out.println("简化方法体大括号");
            lambda3.method();
    
            //4.如果方法体只有一条语句，并且是 return 语句，则可以省略方法体大括号
            ReturnOneParam lambda4 = a -> a+3;
            System.out.println(lambda4.method(5));
    
            ReturnMultiParam lambda5 = (a, b) -> a+b;
            System.out.println(lambda5.method(1, 1));

执行结果如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyOTQ0Mw_size_16_color_FFFFFF_t_70 2]

*  总结
    
     *  简化参数类型，可以不写参数类型，但是必须所有参数都不写
     *  简化参数小括号，如果只有一个参数则可以省略参数小括号
     *  简化方法体大括号，如果方法条只有一条语句，则可以胜率方法体大括号
     *  如果方法体只有一条语句，并且是 return 语句，则可以省略方法体大括号

***路漫漫其修远兮，吾必将上下求索~***  
如果你认为i博主写的不错！写作不易，请点赞、关注、评论给博主一个鼓励吧\*\*转载请注明出处哦\*\*

Java多线程扩展：[Java多线程学习汇总][Java]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyOTQ0Mw_size_16_color_FFFFFF_t_70]: /images/20221023/4ebe0328667d41f3b48daabf88a0bde4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyOTQ0Mw_size_16_color_FFFFFF_t_70 1]: /images/20221023/ca1cb7ccdb544471a139ba76edbf2aa4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyOTQ0Mw_size_16_color_FFFFFF_t_70 2]: /images/20221023/9f3c16dc5fbf4fc893ecfa27f65700af.png
[Java]: https://blog.csdn.net/weixin_43829443/article/details/114359196