线程的底层实现原理-静态代理模式

静态代理模式：
真实对象和代理对象都要实现同一个接口
代理对象要代理真实对象
好处：
代理对象要做很多真实对象做不了的事情
真实对象可以专注做自己的事情

package xiancheng;

public class StaticProxy {
    public static void main(String[] args) {
        You you=new You();
        WeddingCoompany weddingCoompany=new WeddingCoompany(you);
        weddingCoompany.happyMerry();
    }
}
interface Merry{
    void happyMerry();
}
//真实对象
class You implements Merry{
    @Override
    public void happyMerry() {
        System.out.println("聂宝根要结婚了，很开心");
    }
}
//代理对象
class WeddingCoompany implements Merry
{
    private Merry merry;
    public WeddingCoompany(Merry merry)
    {
        this.merry=merry;
    }
    @Override
    public void happyMerry() {
        before();
        this.merry.happyMerry();
        after();
    }

    private void after() {
        System.out.println("结婚之后收尾款");
    }

    private void before() {
        System.out.println("结婚之前布置会场");
    }
}

Lamda表达式的应用
用处：

• 避免内部类定义过多 实质属于函数式编程
  函数式接口是学习lamda表达式的关键
  函数式接口的定义：
  任何接口，如果只包含一个抽象方法，那么他就是一个函数式接口。（比如Runnable接口）
  对于函数式接口来说，可以通过lamda表达式来创建该接口的对象

//lamda接口的实现
public class LamdaTest {
    public static void main(String[] args) {
        //创建实现类对象
        //IIike iIike=new Like();
        //iIike.lamda();
        IIike ilike=()->{
            System.out.println("I like Lamda");
        };
        ilike.lamda();
    }
}
//定义函数式接口
interface IIike{
    void lamda();
}
//实现类
class Like implements IIike {
    @Override
    public void lamda() {
        System.out.println("I like Lamda");
    }
}

含参数的函数式接口的实现

//含参数的函数式接口的简化
public class HanCanLanmadaTest {
    public static void main(String[] args) {
        JiSuanQi jiSuanQi=(a,b,c)->{
            System.out.println(a+b+c);
        };
        jiSuanQi.add(1,2,3);
        
    }
}
//创建函数式接口
interface JiSuanQi{
    void add(int a,int b,int c);
}