静态代理模式

静态代理设计模式：
　总结：真实角色和代理角色；真实角色和代理角色要实现同一个接口，代理角色要持有真实角色的引用。
　好处：代理对象可以做很多真实对象做不了都事情，真实对象专注做自己的事情。
　　在Java中线程的设计就使用了静态代理设计模式，其中自定义线程类实现Runable接口，Thread类也实现了Runalbe接口，在创建子线程的时候，传入了自定义线程类的引用，再通过调用start()方法，调用自定义线程对象的run()方法。实现了线程的并发执行。

public class Test {
    public static void main(String[] args) {
                //Runnable实现类对象，真实角色
               Thread1 role1 = new Thread1();
               //线程类代理角色，该类也实现了Runnable接口，代理角色
               Thread thread1 = new Thread(role1);//传入了真实角色的引用
               thread1.start();
           }
 }
class Thread1 implements Runnable{
    @Override
    public void run() {

    }
}

Thread对象调用线程的start（）方法，在内部调用了真实角色的run()方法。

代码演示：
设计静态代理模式
　　第一步，要有一个共同使用的接口

//共同接口
interface Proxy{
    public abstract void todo();
}

代理角色和真实角色共同实现该接口,代理角色实现需要的功能。

//真实角色
class RealityRole implements Proxy{

    @Override
    public void todo() {
        System.out.println("真实角色的功能");
    }
}

//代理角色
class ProxyRole implements Proxy{
    //持有代理角色的引用
    private Proxy realityRole;

    public ProxyRole(Proxy Role) {
       realityRole =Role;
    }
    @Override
    public void todo() {
        //在真实角色功能运行之前，代理角色做准备工作
        before();
        realityRole.todo();
        after();
    }
    private void after() {
        System.out.println("收尾工作");
    }
    private void before() {
        System.out.println("准备工作");
    }
}

创建真实角色的对象和代理角色的对象，并将真实角色对象的引用传给代理角色，让代理角色去执行功能。

public class StaticTest {
    public static void main(String[] args) {
        //创建真实角色对象
        Proxy realityRole =new RealityRole();
        //创建代理角色对象，并制定真实对象
        ProxyRole proxyRole =new ProxyRole(realityRole);
        //代理角色工作，本质调用的还是角色的功能
        proxyRole.todo();
    }
    }
  

测试结果：
准备工作
真实角色的功能
收尾工作

下面写一个简单的demo 代理结婚程序：

public class StacticProxy {
    public static void main(String[] args) {
        new Thread(()-> System.out.println("我爱你")).start();
        You you=new You();

       // new WeddingCompany(new You()).HappyMarry();
       WeddingCompany weddingCompany=new WeddingCompany(you);
        weddingCompany.HappyMarry();
    }
}

//共同接口
interface Marry{
        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("结婚之前，布置场景");
        }
    }

输出结果：
我爱你
结婚之前，布置场景
你要结婚了，超开心
结婚之后，收尾款

本人拙见，若有什么不当的地方，希望大家多多指正！谢谢！