多线程——静态代理模式、Lambda表达式以及简化

多线程

静态代理模式

总结：

1.真实对象和代理对象都要实现同一个接口

2.代理对象要代理真实角色

作用：

1.代理对象可以为很多真实对象他们不了的事情

2.真实对象专注做自己的事情

   package com.cjp.Proxy;
    
    class StaticProxy {
        public static void main(String[] args) {
            //new Thread(()-> System.out.println("我爱你"));  
            new WeddingCompany(new You()).HappyMarry();
            
        }
    }
    
    
    interface Marry{
        //人间四大喜事
        //久旱逢甘霖
        //他乡遇故知
        //洞房花烛夜
        //金榜题名时
        void HappyMarry();
    }
    
    //真实角色，你去结婚
    class You implements Marry{
    
        @Override
        public void HappyMarry() {
            System.out.println("我要结婚了，我好开心！");
        }
    }
    
    //代理角色帮助你去结婚
    class WeddingCompany implements Marry{
        private Marry target;
    
        public WeddingCompany(Marry target) {
            this.target = target;
        }
    
        @Override
        public void HappyMarry() {
            before();
             this.target.HappyMarry();
             after();
        }
    
        private void after() {
            System.out.println("结婚之后，收尾款");
        }
    
        private void before() {
            System.out.println("结婚之前，布置现场");
        }
    }

Lambda表达式

• 为什么要使用lambda表达式

  1.避免匿名内部类定义过多

  2.可以让你的代码看起来更简洁

  3.去掉了一堆没意义的代码，只留下核心的逻辑。

（Params）->expression[表达式]

（Params）->statement[语句]

（Params）->{statements}

• 理解Functional Interface（函数式接口）：任何接口，如果只包含唯一一个抽象方法，则就是一个函数式接口

例如:

   public interface Runnable{
               public abstract void run();
    }

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

    package com.cjp.lambda;
    
    //1.推导lambda表达式
    public class TestLambda {
    
        //3.静态内部类
        static class  Like2 implements ILike{
    
            @Override
            public void lambda() {
                System.out.println("I like lambda2");
            }
        }
    
        public static void main(String[] args) {
            ILike like = new Like();
            like.lambda();
    
            like = new Like2();
            like.lambda();
    
            //4.局部内部类
             class  Like3 implements ILike{
    
                @Override
                public void lambda() {
                    System.out.println("I like lambda3");
                }
            }
            like = new Like3();
             like.lambda();
    
             //5.匿名内部类 没有名称 必须借助接口或者父类
            like = new ILike() {
                @Override
                public void lambda() {
                    System.out.println("I like lambda4");
                }
            };
            like.lambda();
    
            //6.用lambda简化
            like = ()->{
                System.out.println("I like lambda5");
            };
            like.lambda();
        }
    }
    
    //定义一个接口
    interface   ILike{
        void lambda();
    }
    
    //2.实现类
     class  Like implements ILike{
    
        @Override
        public void lambda() {
            System.out.println("I like lambda");
        }
    }

• Lambda表达式的简化：

 package com.cjp.lambda;
    
    public class TestLambda2 {
        public static void main(String[] args) {
    
        //Lambda表达式简化
            ILove love = (int a)-> {
                    System.out.println("i love you"+a);
                };
        //简化1，去掉参数类型
            love = (a)-> {
                System.out.println("i love you"+a);
            };
    
        //简化2，简化括号
          love =a-> {
              System.out.println("i love you"+a);
          };
    
        //简化3，去掉花括号
        love = a -> System.out.println("I love you"+a);
        
        /**总结：
         * Lambda表达式只能有一行代码的情况下才能简化成一行，如果有多行，那么就用代码快包裹
         * 前提是接口为函数式接口
         * 多个参数也可以去掉参数类型，要去掉就都去掉，必须加上括号*/
             love.love(2);
    
        }
    }
    
    interface ILove{
        void love(int a);
    }

输出结果：

I love you2