2022.8.20 Lamda表达式与静态代理

3、Lamda表达式

λ 希腊字母表中排序第十一位的字母，英语名称为 Lambda
避免匿名内部类定义过多
其实质属于函数式编程的概念
去掉了一堆没有意义的代码,只留下核心逻辑

(params)-> expression[表达式]

(params) -> statement[语句]

[(params)-> {statements}

为什么要使用lambda表达式

避免匿名内部类定义过多
可以让你的代码看起来很简洁
去掉了一·堆没有意义的代码，只留下核心的逻辑。

也许你会说，我看了Lambda表达式，不但不觉得简洁，反而觉得更乱，看不懂了。那是因为我们还没有习惯，用的多了，看习惯了，就好了。

函数式接口

理解Functional Interface (函数式接口) 是学习Java8 lamda表达式的关键
函数式接口的定义
任何接口,如果只包含唯一一个抽象方法,那么它就是一个函数式接口.
```
1  public interface Runnable{
2      public abstract void run();
3  }
```
对于函数式接口,我们可以通过Lambda表达式来创建该接口的对象.

案例

 1 package com.xing.lambda;
 2 
 3 /**
 4  * 推导lamda表达式
 5  */
 6 public class TestLambda {
 7 
 8     public static void main(String[] args) {
 9         ILike like = new Like();
10         like.lamda();
11     }
12 }
13 
14 // 1.定义一个函数式接口
15 interface ILike {
16     void lamda();
17 }
18 
19 // 2.实现类
20 class Like implements ILike {
21     @Override
22     public void lamda() {
23         System.out.println("I like lamda");
24     }
25 }

优化步骤1：

 1 package com.xing.lambda;
 2 
 3 /**
 4  * 推导lamda表达式
 5  */
 6 public class TestLambda {
 7 
 8     //3. 静态内部类
 9     static class Like1 implements ILike {
10         @Override
11         public void lamda() {
12             System.out.println("I like lamda1");
13         }
14     }
15 
16     public static void main(String[] args) {
17         ILike like = new Like();
18         like.lamda();
19 
20         like = new Like1();
21         like.lamda();
22     }
23 }
24 
25 // 1.定义一个函数式接口
26 interface ILike {
27     void lamda();
28 }
29 
30 // 2.实现类
31 class Like implements ILike {
32     @Override
33     public void lamda() {
34         System.out.println("I like lamda");
35     }
36 }

优化步骤2：

 1 package com.xing.lambda;
 2 
 3 /**
 4  * 推导lamda表达式
 5  */
 6 public class TestLambda {
 7 
 8     //3. 静态内部类
 9     static class Like1 implements ILike {
10         @Override
11         public void lamda() {
12             System.out.println("I like lamda1");
13         }
14     }
15 
16     public static void main(String[] args) {
17         ILike like = new Like();
18         like.lamda();
19 
20         like = new Like1();
21         like.lamda();
22 
23 
24 
25         //4.局部内部类
26         class Like2 implements ILike {
27             @Override
28             public void lamda() {
29                 System.out.println("I like lamda2");
30             }
31         }
32         like = new Like2();
33         like.lamda();
34 
35     }
36 }
37 
38 // 1.定义一个函数式接口
39 interface ILike {
40     void lamda();
41 }
42 
43 // 2.实现类
44 class Like implements ILike {
45     @Override
46     public void lamda() {
47         System.out.println("I like lamda");
48     }
49 }

优化步骤3：

 1 package com.xing.lambda;
 2 
 3 /**
 4  * 推导lamda表达式
 5  */
 6 public class TestLambda {
 7 
 8     //3. 静态内部类
 9     static class Like1 implements ILike {
10         @Override
11         public void lamda() {
12             System.out.println("I like lamda1");
13         }
14     }
15 
16     public static void main(String[] args) {
17         ILike like = new Like();
18         like.lamda();
19 
20         like = new Like1();
21         like.lamda();
22 
23 
24 
25         //4.局部内部类
26         class Like2 implements ILike {
27             @Override
28             public void lamda() {
29                 System.out.println("I like lamda2");
30             }
31         }
32         like = new Like2();
33         like.lamda();
34 
35 
36         //5.匿名内部类,没有类的名称,必须借助接口或者父类
37         like = new ILike () {
38             @Override
39             public void lamda() {
40                 System.out.println("I like lamda3");
41             }
42         };
43         like.lamda();
44 
45     }
46 }
47 
48 // 1.定义一个函数式接口
49 interface ILike {
50     void lamda();
51 }
52 
53 // 2.实现类
54 class Like implements ILike {
55     @Override
56     public void lamda() {
57         System.out.println("I like lamda");
58     }
59 }

最终版：

 1 package com.xing.lambda;
 2 
 3 /**
 4  * 推导lamda表达式
 5  */
 6 public class TestLambda {
 7 
 8     //3. 静态内部类
 9     static class Like1 implements ILike {
10         @Override
11         public void lamda() {
12             System.out.println("I like lamda1");
13         }
14     }
15 
16     public static void main(String[] args) {
17         ILike like = new Like();
18         like.lamda();
19 
20         like = new Like1();
21         like.lamda();
22 
23 
24 
25         //4.局部内部类
26         class Like2 implements ILike {
27             @Override
28             public void lamda() {
29                 System.out.println("I like lamda2");
30             }
31         }
32         like = new Like2();
33         like.lamda();
34 
35 
36         //5.匿名内部类,没有类的名称,必须借助接口或者父类
37         like = new ILike () {
38             @Override
39             public void lamda() {
40                 System.out.println("I like lamda3");
41             }
42         };
43         like.lamda();
44 
45         //6.lamda简化
46         like = () ->{
47             System.out.println("I like lamda4");
48         };
49         like.lamda();
50 
51     }
52 }
53 
54 // 1.定义一个函数式接口
55 interface ILike {
56     void lamda();
57 }
58 
59 // 2.实现类
60 class Like implements ILike {
61     @Override
62     public void lamda() {
63         System.out.println("I like lamda");
64     }
65 }

案例2:

 1 package com.xing.lambda;
 2 
 3 public class TestLambda2 {
 4     
 5     public static void main(String[] args) {
 6         // 1.lamda
 7         ILove love = (int a) -> {
 8             System.out.println("I love you -->" + a);
 9         };
10         love.love(520);
11         
12         // 2.lamda简化 去掉参数类型
13         love = (a) -> {
14             System.out.println("I love you -->" + a);
15         };
16         love.love(1314);
17         
18         // 3.lamda简化 去掉小括号
19         love = a -> {
20             System.out.println("I love you -->" + a);
21         };
22         love.love(1111);
23         
24         // 3.lamda简化  去掉大括号
25         love = a -> System.out.println("I love you -->" + a);
26         love.love(9999);
27         /**总结:
28          * {}简略的条件是只能有一行代码,多行{}就不能简略了
29          * 前提是接口为函数式接口(只能有一个方法)
30          * 多个参数也可以去掉参数类型,要去掉就都去掉,必须加上()
31          */
32     }
33 }
34 
35 // 接口
36 interface ILove {
37     void love(int a);
38 }

4、静态代理

结婚案例

 1 package com.xing.proxy;
 2 
 3 /**
 4  * 静态代理:结婚案例
 5  * 静态代理模式总结
 6  * 真实对象和代理对象都要实现同一个接口
 7  * 代理对象要代理真实角色
 8  */
 9 public class StaticProxy {
10     public static void main(String[] args) {
11         WeddingCompany weddingCompany = new WeddingCompany(new You());
12         weddingCompany.happyMarry();
13     }
14 }
15 
16 //结婚
17 interface Marry {
18     void happyMarry();
19 }
20 
21 //真实角色:你去结婚
22 class You implements Marry {
23     @Override
24     public void happyMarry() {
25         System.out.println("小明要结婚了,超开心");
26     }
27 }
28 
29 //代理角色:帮助你结婚   婚庆公司
30 class WeddingCompany implements Marry {
31     private Marry target;//代理-->真实目标角色角色,帮谁结婚
32 
33     public WeddingCompany(Marry target) {
34         this.target = target;
35     }
36 
37     @Override
38     public void happyMarry() {
39         before();
40         this.target.happyMarry();
41         after();
42     }
43 
44     private void before() {
45         System.out.println("结婚之前,布置现场");
46     }
47 
48     private void after() {
49         System.out.println("结婚之后,收尾款");
50     }
51 }

对比静态代理与Thread

 1 /**
 2  * 线程中的代理模式
 3  */
 4 public class StaticProxy {
 5     public static void main(String[] args) {
 6         //代理Runnable接口
 7         new Thread(()-> System.out.println("我爱你")).start();
 8         
 9         new WeddingCompany(new You()).happyMarry();
10     }
11 }
12 //WeddingCompany...上一个文件定义过了这里就直接使用了

总结

真实对象和代理对象都要实现一个接口代理对象要代理真实角色

好处

代理对象可以做很多真实对象做不了的事情真实对象专注做自己的事

posted @ 2022-08-20 23:45 暴躁C语言阅读(36) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

暴躁C语言