静态代理，和线程继承Runnable的联系

静态代理

• 真实对象和代理对象都是实现一个接口，

• 代理对象要代理真实对象，也就是真实对象传入代理对象

  • //婚庆公司就是Thread，是静态代理
    MarryCompany marryCompany=new MarryCompany(you);
    

好处：

• 代理对象做真实对象做不了的
• 真实对象专注于自己的事

线程继承Runnable，经常说是代理，这就是静态代理，满足两个条件：
1.都实现统一接口Runnable
2.实例化对象传入了Thread new Thread(testThread3).start();

//Runnable接口
public class TestThread3 implements Runnable{

    @Override
    public void run() {
        //run（）方法线程体
        for(int i=0;i<20;++i){
            System.out.println("我在看代码----"+i);
        }
    }

    public static void main(String[] args) {
        //实现Runnable接口的实例化对象
        TestThread3 testThread3 = new TestThread3();
        //代理Thread，传入对象
        new Thread(testThread3).start();
        for(int i=0;i<20;++i){
            System.out.println("我在学习Thread----"+i);
        }
    }
}

看一下结婚的例子，你结婚，婚庆公司给你办场地，收钱啥的，你就只管结婚就行：
1.共同的实现接口：Marry结婚

public interface Marry {
    void marry();
}

2.真实对象：结婚的你

public class You implements Marry {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public void marry() {
        System.out.println(name+"结婚了，贼开心");
    }
}

3.静态代理对象：婚庆公司

public class MarryCompany implements Marry{

    private You target;

    public MarryCompany(You 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("结婚后");

    }


}

4。实现结婚的测试类

public class StaticProxy {
    public static void main(String[] args) {
        //you就是类似于实现Runnable接口的对象
        You you=new You();
        you.setName("子涵");

        //婚庆公司就是类似于Thread，是静态代理，传入真实对象
        MarryCompany marryCompany=new MarryCompany(you);
        marryCompany.marry();
    }

}