静态代理设计模式：

　　　　　　要求：真实角色，代理角色；真实角色和代理角色要实现同一个接口，代理角色要持有真实角色的引用。

　　在Java中线程的设计就使用了静态代理设计模式，其中自定义线程类实现Runable接口，Thread类也实现了Runalbe接口，在创建子线程的时候，传入了自定义线程类的引用，再通过调用start()方法，调用自定义线程对象的run()方法。实现了线程的并发执行。

 1 public class Test2 {
 2
 3     public static void main(String[] args) {
 4         //Runnable实现类对象，真实角色
 5         Thread1 role1 = new Thread1();
 6         //线程类代理角色，该类也实现了Runnable接口，代理角色
 7         Thread thread1 = new Thread(role1);//传入了真实角色的引用
 8
 9         thread1.start();
10
11     }
12 }
13
14 class Thread1 implements Runnable {
15
16     @Override
17     public void run() {
18         //TODO
19     }
20
21 }

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

设计静态代理模式

　　第一步，要有一个共同使用的接口

1 // 共同的接口
2 public interface Proxy {
3     public abstract void todo();
4 }

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

 1 // 真实角色
 2 class RealityRole implements Proxy {
 3
 4     @Override
 5     public void todo() {
 6         System.out.println("真实角色的功能");
 7     }
 8 }
 9
10 // 代理角色
11 class ProxyRole implements Proxy {
12     // 持有代理角色的引用
13     private Proxy realityRole;
14
15     public ProxyRole() {
16
17     }
18
19     //传入一个真实角色
20     public ProxyRole(Proxy role) {
21         realityRole = role;
22     }
23     @Override
24     public void todo() {
25         //在真实角色功能运行之前，代理角色做准备工作
26         doBefore();
27         //执行真实角色的功能
28         realityRole.todo();
29         //代理角色的收尾工作
30         doAfter();
31     }
32     private void doBefore() {
33         System.out.println("准备工作");
34     }
35     private void doAfter() {
36         System.out.println("收尾工作");
37     }
38 }

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

 1 public class Test {
 2     public static void main(String[] args) {
 3         //创建真实角色对象
 4         Proxy realityRole = new RealityRole();
 5         //创建代理角色对象，并制定真实对象
 6         ProxyRole proxyRole = new ProxyRole(realityRole);
 7         //代理角色工作，本质调用的还是真实角色的功能
 8         proxyRole.todo();
 9     }
10 }运行结果：　　准备工作　　真实角色的功能　　收尾工作