浅谈多线程与静态代理

//买房代理类
public class BuyHouseProxy {

    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("买房！");
            }
        }).start();
        new Thread(()-> System.out.println("买房")).start();
        //这里我们直接使用代理类对其进行调用(这里是有参构造，故需要对其传入参数)
        new Agent(new Person()).buyHouse();
    }
}
//创建一个买房的接口
interface BuyHouse{
    void buyHouse();
}

//买家类实现买房的接口，继承里边的方法
class Person implements BuyHouse{
    @Override
    public void buyHouse() {
        System.out.println("张三想买【东投国贸-海棠之恋】");
    }
}
//房产中介类
class Agent implements BuyHouse{
    //创建接口对象
    private BuyHouse buyer;
    //使用房产中介类构造对其进行赋值(我们在外部调用时，就可以直接通过构造方法进行赋值传递)
    public Agent(BuyHouse buyer){
        this.buyer=buyer;
    }
    @Override
    public void buyHouse() {
        //在用户买房之前
        before();
        //用户买房
        this.buyer.buyHouse();//使用买家方法调用买房对象
        //在用户买房之后
        after();
    }
    private void before() {
        System.out.println("房产中介需要先提前带客户实地参观样板房");
    }
    private void after() {
        System.out.println("陪着顾客交付房屋、领钥匙、放礼炮");
    }
}

从以上代码我们可以发现我们使用静态代理来实现目标类的方法和使用Thread类来实现多线程是一致的，也就是说Thread类实现多线程底层也是静态代理

这里使用lambda表达式简化创建匿名内部类对象的过程
new Thread(new Runnable() {
@Override
public void run() {
System.out.println(“买房！”);
}
}).start();
//使用labam表达式表达式改写
new Thread(()-> System.out.println(“买房”)).start();

[Java之Lambda表达式]—让你的代码更简洁

1、给代理对象一个目标对象，并由代理对象控制目标的引用；

//创建接口对象
    private BuyHouse buyer;
    //使用房产中介类构造对其进行赋值(我们在外部调用时，就可以直接通过构造方法进行赋值传递)
    public Agent(BuyHouse buyer){
        this.buyer=buyer;
    }

优点：
1、目标类可以专心实现自己方法；
2、无需修改目标对象的前提下，就可以扩展目标对象的功能；
缺点：
1、不够灵活，如果在接口中新增其他方法，目标类、代理类都需要新增方法；