Proxy estático de subprocesos múltiples, expresión Lambda (3)

Utilice un ejemplo de matrimonio para lograr un proxy estático frente a un hilo

Tu: objeto real
Compañía de bodas: actuando en tu nombre, ayudándote a lidiar con el matrimonio
Matrimonio: puede implementar la interfaz de matrimonio

//静态代理模式总结
//真实对象和代理对象都要实现同一个接口
//代理对象要代理真实角色

//好处：
    //代理对象可以做真实对象做不了的事情
    //真实对象专注做自己的事情

public class StaticProxy {
      
      
    public static void main(String[] args) {
      
      
        You you=new You();//你要结婚
        //you.HappyMarry();原先要这样调
        //线程是怎么实现调用的
        /*new Thread(new Runnable() {
            @Override
            public void run() {

            }
        }).start();*/
        //用浪答表达式简化
        //Thread就是代理，代理了一个真实的Runnable接口，调用了start()方法
        new Thread(()-> System.out.println("我爱你")).start();

        //把下面的两行代码简写成一行代码
        new WeddingCompany(new You()).HappyMarry();//再调用HappyMarry()方法，HappyMarry()相当于线程的start()

//        WeddingCompany weddingCompany=new WeddingCompany(you);//现在只要这样调，你只要花钱给婚庆公司就好了
//        weddingCompany.HappyMarry();
    }


}
interface Marry{
      
      
    /*
    人间四大喜事
    1.久旱逢甘露
    2.他乡遇故知
    3.洞房花烛夜
     */

    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("结婚之前，布置现场");
    }
}

Expresión lambda

λ La undécima letra del alfabeto griego, el nombre en inglés es Lambda
Evite demasiadas definiciones anónimas de clases internas
Su esencia pertenece al concepto de programación funcional

/*
推导lanmbda表达式
 */
public class TestLambda1 {
      
      
    //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();//接口去new了一个实现类
        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();
    }
}

//1.定义一个函数式接口
interface ILike{
      
      
    void lambda();
}

//2.实现类
class Like implements ILike{
      
      
    @Override
    public void lambda() {
      
      
        System.out.println("I like lambda");
    }

Las expresiones lambda utilizan parámetros :

public class TestLambda2 {
        
        

    public static void main(String[] args) {
        
        
          ILove love=null;

 /*       //1.lambda表示简化
        love=(int a,int b)-> {
              System.out.println("i love you -->"+a);
        };

        //简化1.去掉参数类型
        love=(a,b)-> {
            System.out.println("i love you -->"+a);
        };

        //简化2.简化括号
        love=a-> {
            System.out.println("i love you -->"+a);          
        };*/
        
 		love=(a,b)-> {
        
        
            System.out.println("i love you -->"+a);
            System.out.println("i love you -->too"+b);
        };

        //总结：
            //lamnda表达式只能有一行代码的情况下才能简化成为一行，如果有多行，那么就用代码块包裹。
            //前提是接口为函数式接口
            //多个参数也可以掉参数类型，要去掉就都去掉

        love.love(521,502);
    }
}

interface ILove{
        
        
    void love(int a,int b);
}

class Love implements ILove{
        
        

    @Override
    public void love(int a,int b) {
        
        
        System.out.println("i love you -->"+a);
    }
}

Proxy estático de subprocesos múltiples, expresión Lambda (3)

Proxy estático de subprocesos múltiples, expresión Lambda (3)

Supongo que te gusta