Thread类-线程静态代理实现

先说一个小例子：
你要准备结婚，举办婚礼，需要找婚庆公司，因为不可能一场婚礼的所有事情都由你来做：
婚庆公司布置场景，请司仪，写请帖…
而你，作为新人，只需要去参加婚礼，说表白词，誓言…
婚庆公司是代理对象，你是真实对象，婚庆公司代理你

话不多说，上代码

package com.bes.mybatis_plus.Test1;

/**
 * 静态代理模式总结：
 * 真是对象和代理对象都要实现同一个接口
 * 代理对象要代理真实角色（包含继承同一个接口的真实对象target）
 */

/**
 * 好处： 代理对象可以做很多真实对象做不了的事
 * 真实对象专注做自己的事情
 */
public class StaticProxy {
    public static void main(String[] args) {
        You you = new You();

        new Thread(()->{
            System.out.println("创建线程的lambda写法");
        }).start();
        //老方法
//        WeddingCompany weddingCompany = new WeddingCompany(you);
//        weddingCompany.HappyMarry();
        //lambda写法
        new WeddingCompany(you).HappyMarry();
        /**
         * 线程就和婚庆公司一样，静态代理模式
         * 婚庆公司WeddingCompany实现Marry接口，包含target对象，此处target对象是也实现Marry接口的You类
         * You可以做自己的事，其他事婚庆公司WeddingCompany来做
         * Thread类实现Runnable接口，包含target对象，此处arget对象事，你自定义的类（也实现实现Runnable接口）
         * Thread类关注线程的事，自定义线程做其他事
         */

    }
}

interface Marry{
    void HappyMarry();
}

class You implements  Marry{
    @Override
    public void HappyMarry() {
        System.out.println("你要结婚了~新郎不是我~哦 太多的难过，我该对谁说");
    }
}

class WeddingCompany implements Marry{
	//代理的真实对象
    private Marry target;
	//构造函数
    WeddingCompany(Marry target){
        this.target = target;
    }
    @Override
    public void HappyMarry() {
        before();
        this.target.HappyMarry();
        after();
    }

    private void before() {
        System.out.println("婚庆公司婚前准备");
    }

    private void after() {
        System.out.println("婚庆公司婚后打扫现场");
    }
}

婚庆公司和你都实现同一个接口-Marry接口，婚庆公司代理真实对象（实现Marry接口的类），这样只要实现Marry接口，都可以交给婚庆公司代理，而你可以专注做自己的事情，各做各的

而线程也是一样：
Thread类实现Runnable接口，你自定义的线程类也实现Runnable接口。
Thread类去做线程的事，你自定义的线程类，在run()方法内写逻辑代码即可。
Thread类代理你自定义的线程类