• 多线程详解（二）静态代理模式&Lambda表达式

    目录

    一、静态代理模式

    二、Lambda表达式 

    2.1 为什么要使用lambda表达式

    2.2 函数式接口

    2.3 函数式编程概念

    2.4 推导Lambda表达式

    2.5 含参Lambda表达式推导过程

    2.6 简化Lambda表达式

    2.7 总结

    一、静态代理模式

    要求：真实对象和代理对象都要实现同一个接口

               代理对象要代理真实角色

    好处：代理角色可以做好多真实角色做不了的事

               真实角色可专注于自己的事情

    引入案例：结婚

    你：真实角色

    婚庆公司：代理你，帮你处理结婚的事

    结婚：通过接口实现

    1. //静态代理模式
    2. public class StaticProxy {
    3.     public static void main(String[] args) {
    4.         //需要一个代理角色，服务于真实角色
    5.         WeddingCompany weddingCompany = new WeddingCompany(new You());
    6.         weddingCompany.HappyMarry();
    7.     }
    8. }
    9.  
    10. //共同接口
    11. interface Marry{
    12.     void HappyMarry();
    13. }
    14.  
    15. //真实角色
    16. class You implements Marry{
    17.     @Override
    18.     public void HappyMarry() {
    19.         System.out.println("happy");
    20.     }
    21. }
    22.  
    23. //代理角色
    24. class WeddingCompany implements Marry{
    25.     //目标对象
    26.     private Marry target;
    27.  
    28.     public  WeddingCompany(Marry target){
    29.         this.target=target;
    30.     }
    31.  
    32.     @Override
    33.     public void HappyMarry() {
    34.         before();
    35.         this.target.HappyMarry();
    36.         after();
    37.     }
    38.  
    39.     private void after() {
    40.         System.out.println("结婚后");
    41.     }
    42.  
    43.     private void before() {
    44.         System.out.println("结婚前");
    45.     }
    46. }

    运行结果：

    二、Lambda表达式 

    2.1 为什么要使用lambda表达式

            1）避免匿名内部类过多

            2）可以让你的代码看起来很简洁

            3）去掉了一些没有意义的代码，只留下核心的逻辑

    2.2 函数式接口

            理解Functional Interfa（函数式接口）是学习Java8 Lambda表达式的关键所在

            函数式接口定义：

                    任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口

                    对于函数式接口，我们可以通过Lambda表达式来创建该接口的对象

    2.3 函数式编程概念

            (params) -> expression[表达式]

            (params) -> statement[语句]

            (params) -> {statement}

    2.4 推导Lambda表达式

    最初写法：

    1. public class TestLambda01 {
    2.     public static void main(String[] args) {
    3.         //用接口创建对象 接口new实现类
    4.         ILike like = new Like();
    5.         like.Lambda();
    6.     }
    7. }
    8.  
    9. //定义一个函数式接口
    10. interface ILike{
    11.     void Lambda();
    12. }
    13.  
    14. //实现类
    15. class Like implements ILike{
    16.     @Override
    17.     public void Lambda() {
    18.         System.out.println("i like lambda");
    19.     }
    20. }

    使用静态内部类进行第一次优化：

    1. public class TestLambda01 {
    2.     //3.静态内部类
    3.     static class Like2 implements ILike{
    4.         @Override
    5.         public void Lambda() {
    6.             System.out.println("i like lambda02");
    7.         }
    8.     }
    9.  
    10.     public static void main(String[] args) {
    11.         //用接口创建对象 接口new实现类
    12.         ILike like = new Like();
    13.         like.Lambda();
    14.         ILike like2 = new Like2();
    15.         like2.Lambda();
    16.     }
    17. }
    18.  
    19. //1.定义一个函数式接口
    20. interface ILike{
    21.     void Lambda();
    22. }
    23.  
    24. //2.实现类
    25. class Like implements ILike{
    26.     @Override
    27.     public void Lambda() {
    28.         System.out.println("i like lambda01");
    29.     }
    30. }

    使用局部内部类进行第二次优化：

    1. public class TestLambda01 {
    2.     //3.静态内部类
    3.     static class Like2 implements ILike{
    4.         @Override
    5.         public void Lambda() {
    6.             System.out.println("i like lambda02");
    7.         }
    8.     }
    9.  
    10.     public static void main(String[] args) {
    11.         //用接口创建对象 接口new实现类
    12.         ILike like = new Like();
    13.         like.Lambda();
    14.  
    15.         ILike like2 = new Like2();
    16.         like2.Lambda();
    17.  
    18.         //4.局部内部类
    19.         class Like3 implements ILike{
    20.             @Override
    21.             public void Lambda() {
    22.                 System.out.println("i like lambda03");
    23.             }
    24.         }
    25.  
    26.         ILike like3 = new Like3();
    27.         like3.Lambda();
    28.     }
    29. }
    30.  
    31. //1.定义一个函数式接口
    32. interface ILike{
    33.     void Lambda();
    34. }
    35.  
    36. //2.实现类
    37. class Like implements ILike{
    38.     @Override
    39.     public void Lambda() {
    40.         System.out.println("i like lambda01");
    41.     }
    42. }

    使用匿名内部类进行第三次优化：

    1. public class TestLambda01 {
    2.     //3.静态内部类
    3.     static class Like2 implements ILike{
    4.         @Override
    5.         public void Lambda() {
    6.             System.out.println("i like lambda02");
    7.         }
    8.     }
    9.  
    10.     public static void main(String[] args) {
    11.         //用接口创建对象 接口new实现类
    12.         ILike like = new Like();
    13.         like.Lambda();
    14.  
    15.         ILike like2 = new Like2();
    16.         like2.Lambda();
    17.  
    18.         //4.局部内部类
    19.         class Like3 implements ILike{
    20.             @Override
    21.             public void Lambda() {
    22.                 System.out.println("i like lambda03");
    23.             }
    24.         }
    25.  
    26.         ILike like3 = new Like3();
    27.         like3.Lambda();
    28.  
    29.         //5.匿名内部类   没有类的名字，必须借助父类或者接口
    30.         like=new ILike(){
    31.             @Override
    32.             public void Lambda() {
    33.                 System.out.println("i like lambda04");
    34.             }
    35.         };
    36.  
    37.         like.Lambda();
    38.     }
    39. }
    40.  
    41. //1.定义一个函数式接口
    42. interface ILike{
    43.     void Lambda();
    44. }
    45.  
    46. //2.实现类
    47. class Like implements ILike{
    48.     @Override
    49.     public void Lambda() {
    50.         System.out.println("i like lambda01");
    51.     }
    52. }

    最后使用Lambda简化，完成Lambda表达式的整个推导过程：

    1. //推导Lanbda表达式
    2. public class TestLambda01 {
    3.     //3.静态内部类
    4.     static class Like2 implements ILike{
    5.         @Override
    6.         public void Lambda() {
    7.             System.out.println("i like lambda02");
    8.         }
    9.     }
    10.  
    11.     public static void main(String[] args) {
    12.         //用接口创建对象 接口new实现类
    13.         ILike like = new Like();
    14.         like.Lambda();
    15.  
    16.         ILike like2 = new Like2();
    17.         like2.Lambda();
    18.  
    19.         //4.局部内部类
    20.         class Like3 implements ILike{
    21.             @Override
    22.             public void Lambda() {
    23.                 System.out.println("i like lambda03");
    24.             }
    25.         }
    26.  
    27.         ILike like3 = new Like3();
    28.         like3.Lambda();
    29.  
    30.         //5.匿名内部类   没有类的名字，必须借助父类或者接口
    31.         like=new ILike(){
    32.             @Override
    33.             public void Lambda() {
    34.                 System.out.println("i like lambda04");
    35.             }
    36.         };
    37.  
    38.         like.Lambda();
    39.  
    40.         //6.使用Lambda简化
    41.         like=() -> {
    42.             System.out.println("i like lambda05");
    43.         };
    44.  
    45.         like.Lambda();
    46.     }
    47. }
    48.  
    49. //1.定义一个函数式接口
    50. interface ILike{
    51.     void Lambda();
    52. }
    53.  
    54. //2.实现类
    55. class Like implements ILike{
    56.     @Override
    57.     public void Lambda() {
    58.         System.out.println("i like lambda01");
    59.     }
    60. }

    2.5 含参Lambda表达式推导过程

    第一步：写接口、实现类，并通过接口new一个实现类，调用对应的方法

    1. public class TestLambda02 {
    2.     public static void main(String[] args) {
    3.         ILove love = new Love();
    4.         love.love(2);
    5.     }
    6. }
    7.  
    8. //接口
    9. interface ILove{
    10.     void love(int a);
    11. }
    12.  
    13. //实现类
    14. class Love implements ILove{
    15.     @Override
    16.     public void love(int a) {
    17.         System.out.println("i love you --> "+a+" times");
    18.     }
    19. }

    第二步：改写为静态内部类

    1. public class TestLambda02 {
    2.     //静态内部类
    3.     static class Love implements ILove{
    4.         @Override
    5.         public void love(int a) {
    6.             System.out.println("i love you --> "+a+" times");
    7.         }
    8.     }
    9.     public static void main(String[] args) {
    10.         ILove love=new Love();
    11.         love.love(3);
    12.     }
    13. }
    14.  
    15. //接口
    16. interface ILove{
    17.     void love(int a);
    18. }

    第三步：改写为局部内部类

    1. public class TestLambda02 {
    2.     public static void main(String[] args) {
    3.         //局部内部类
    4.         class Love implements ILove{
    5.             @Override
    6.             public void love(int a) {
    7.                 System.out.println("i love you --> "+a+" times");
    8.             }
    9.         }
    10.  
    11.         ILove love=new Love();
    12.         love.love(4);
    13.     }
    14. }
    15.  
    16. //接口
    17. interface ILove{
    18.     void love(int a);
    19. }

    第四步：改写为匿名内部类

    1. public class TestLambda02 {
    2.     public static void main(String[] args) {
    3.         //匿名内部类
    4.         new ILove(){
    5.             @Override
    6.             public void love(int a) {
    7.                 System.out.println("i love you --> "+a+" times");
    8.             }
    9.         } .love(5);
    10.     }
    11. }
    12.  
    13. //接口
    14. interface ILove{
    15.     void love(int a);
    16. }

    最后一步：Lambda表达式

    1. public class TestLambda02 {
    2.     public static void main(String[] args) {
    3.         //Lambda表达式
    4.         ILove love=(int a)->{
    5.                 System.out.println("i love you --> "+a+" times");
    6.         } ;
    7.         love.love(6);
    8.     }
    9. }
    10.  
    11. //接口
    12. interface ILove{
    13.     void love(int a);
    14. }

    2.6 简化Lambda表达式

    1）去掉参数类型

    1. public class TestLambda02 {
    2.     public static void main(String[] args) {
    3.         //Lambda表达式
    4.         //简化一：去掉参数类型
    5.                 ILove love=(a)->{
    6.                 System.out.println("i love you --> "+a+" times");
    7.         } ;
    8.         love.love(7);
    9.     }
    10. }
    11.  
    12. //接口
    13. interface ILove{
    14.     void love(int a);
    15. }

    2）去掉括号（）

    1. public class TestLambda02 {
    2.     public static void main(String[] args) {
    3.         //Lambda表达式
    4.         //简化二：去掉括号
    5.         ILove love=a->{
    6.             System.out.println("i love you --> "+a+" times");
    7.         } ;
    8.         love.love(8);
    9.     }
    10. }
    11.  
    12. //接口
    13. interface ILove{
    14.     void love(int a);
    15. }

    3）去掉 { }

    1. public class TestLambda02 {
    2.     public static void main(String[] args) {
    3.         //Lambda表达式
    4.         //简化三：去掉{ }
    5.         ILove love=a->
    6.             System.out.println("i love you --> "+a+" times");
    7.         love.love(9);
    8.     }
    9. }
    10.  
    11. //接口
    12. interface ILove{
    13.     void love(int a);
    14. }

    2.7 总结

    1.Lambda表达式当只有一行代码的情况下，才能简化成一行，即去{}， 如果有多行，则必须用代码块包裹

    2.前提是接口为函数式接口（只有一个方法的接口）

    3.多个参数也可以去掉参数类型，要去掉就都去掉，但必须加上括号

  • 相关阅读:
    营销妙招：链动2+1渠道搭建团队裂变
    stm32flash一键ISP烧录单片机
    基于JAVA天津城建大学教室查询预约管理系统计算机毕业设计源码+数据库+lw文档+系统+部署
    IDEA、DataGrip、Navicat连接openGauss数据库
    C语言基础（下）
    js 面试整合1
    小程序AI智能名片S2B2C商城系统：四大主流商业模式深度解析与实战案例分享
    【Android入门】8、Service 后台线程、多线程、IntentService
    【FPGA教程案例61】硬件开发板调试1——初识FPGA开发板,通过verilog控制LED灯，按键开关等
    Day07
  • 原文地址：https://blog.csdn.net/qq_61727355/article/details/125997295