多线程详解——前期巩固之静态代理和Lambda表达式（二）

静态代理

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

好处：

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

//静态代理
public class StaticProxy {
    public static void main(String[] args) {

		You you = new You();//真实对象
        WeddingCompany weddingCompany = new WeddingCompany(you);//代理对象
        weddingCompany.marry();
        /*
            结婚之前，布置现场。
            你要结婚了！
            结婚之后，收尾款
         */
    }
}

interface Marry{
    void marry();
}


//真实角色，结婚人是你
class You implements Marry{

    @Override
    public void marry() {
        System.out.println("你要结婚了！");
    }
}

//代理角色，帮助你结婚
class WeddingCompany implements Marry {

    //目标对象
    private Marry target;

    public WeddingCompany(Marry target) {
        this.target = target;
    }

    @Override
    public void marry() {
        before();
        //帮助真实对象结婚
        this.target.marry();
        after();
    }
    private void before() {
        System.out.println("结婚之前，布置现场。");
    }
    private void after() {
        System.out.println("结婚之后，收尾款");
    }
}

---

Lambda表达式

使用lambda表达式原因

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

函数式接口

• 任何接口只包含唯一一个抽象方法，那么它就是一个函数式接口
• 对于函数式接口，我们可以通过lambda表达式来创建改接口的对象

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

推理Lambda表达式的过程

传统实例化创建对象调用方法==》静态内部类==》局部内部类==》匿名内部类==》Lambda表达式

public class TestLambda01 {

    //3.静态内部类
    static class Like2 implements Ilike{
        @Override
        public void lambda() {
            System.out.println("I like Lambda22222.");
        }
    }

    public static void main(String[] args) {

        Ilike like = new Like();
        like.lambda();//I like Lambda.

        like = new Like2();
        like.lambda();//I like Lambda22222.

        //4.局部内部类
        class Like3 implements Ilike{
            @Override
            public void lambda() {
                System.out.println("I like Lambda33333.");
            }
        }
        like = new Like3();
        like.lambda();//I like Lambda33333.


        //5.匿名内部类，没有类的名称，必须借助接口或者父类
        like = new Ilike() {
            @Override
            public void lambda() {
                System.out.println("I like Lambda44444.");
            }
        };
        like.lambda();//I like Lambda44444.

        //6.用Lambda简化
        like = () ->{
            System.out.println("I like Lambda55555.");
        };
        like.lambda();//I like Lambda55555.
    }

}

//1.实现一个函数式接口
interface Ilike{
    void lambda();
}

//2.实现类
class Like implements Ilike{

    @Override
    public void lambda() {
        System.out.println("I like Lambda.");
    }
}

PS：1、lambda表达式只能有一行代码的情况下才能简化成为一行，如果有多行，那么就用代码块包裹。2、前提是接口为函数式接口。3、多个参数也可以去掉参数类型，要去掉就全部去掉，必须加上括号。
（文章通过狂神说视频内容进行总结。）