学习（静态代理，lambda表达式）

Java学习—静态代理，lambda表达式

静态代理

所谓代理，就是指某人或某个组织替你做某事，这年头常见的中介，包括房介，车介，婚介等等，都是代理，***而在Java当中，代理分为两种方法，一种是静态代理，另一种是动态代理。***本节学习静态代理。在Java中，静态代理多用于多线程，通过两个类同时实现一个接口，从而在一个类的构造器当中调用另外一个类的对象，进而达到代理的目的

下面以婚介公司为例：

public class StaticProxy {
    public static void main(String[] args) {
        new Thread( ()-> System.out.println("结婚啦！")).start();
        new weddingFirm(new me()).HappyMarry();
    }
}
interface Marry{//该接口为结婚接口

    void HappyMarry();

}
//结婚者
class me implements Marry{
    @Override
    public void HappyMarry() {
        System.out.println("结婚了，超级开心！");

    }
}

//代理结婚的公司
class weddingFirm implements Marry{

    private Marry me;//这里是关键和精华！！！！！！！

    public weddingFirm(Marry me) {
        this.me = me;//这里通过构造器来获取对象
    }


    @Override
    public void HappyMarry() {
        before();//结婚前
        this.me.HappyMarry();
        after();//结婚后

    }

    private void after() {
        System.out.println("结婚之后，收尾款");
    }

    private void before() {
        System.out.println("结婚之前，布置现场");
    }
}

这个例子当中，先创建一个结婚的接口，随后让me和weddingFirm来实现这个接口，在weddingFirm当中，创建一个这个构造器

 private Marry me;//这里是关键和精华！！！！！！！

系统正是通过这个来进行代理，取得me的对象后就可以对其进行操作。这便是代理

最后，将me对象new出来并放入new的、出来的weddingFirm对象当中，调用HappyMarry方法即可完成代理。

提醒一句：本质上Thread类继承了Runnable接口，所以通过实现Runnable接口其实相当于是Thread类通过Runnable接口来对你所创建的类进行了静态代理。这也就和我们所学的知识扯上了关系。

---

lambda表达式

lambda表达式本质上是将实现函数式接口的过程进行简化，所谓函数式接口就是指只有一个方法的接口，例如Runnable接口就是一个典型的函数式接口。而Thread类又是继承了Runnable接口，所以创建一个线程对象可以用lambda表达式进行简化。

首先，如果要实现一个接口并重写其方法，我们最粗暴的办法就是直接在外面实现

interface Like{
    void lambda();
}
class Ilike implements Like{
    @Override
    public void lambda() {
        System.out.println("1");
    }

通过这种方式来对接口及逆行实现

我们可以进行优化，第一，我们可以将其放入内部类当中，这样可以让外面的类少一点。

第二，我们可以创建一个匿名内部类，这样就可以一次性使用，节约了空间和代码。

第三，我们就可以直接用lambda表达式

如下

public class Lambda {

    public static void main(String[] args) {
        Bird bird ;//可以用父类或者是接口来创造一个临时的对象

        bird=()->{
            System.out.println("我是鸟！");//这里通过临时的对象来重写接口的唯一方法，这样的简化就是lambda表达式
        };
        bird.fly();

        Love love;
        love=(times,name)->//lambda表达式可以简化参数类型和括号以及花括号,如果有多个参数，那么可以把每个参数类型都一起去掉
            //去参数，要么不去，要么全去掉.
            System.out.println("i love you "+times+" times!");

        love.love(3000,"小明");
    }
}
interface Bird{
    void fly();
interface Love{
    void love(int a ,String b);

lambda表达式的用法就是将一个需要实现接口的对象bird，这样初始化

bird=(这里是函数式接口的内部方法的参数)->{这里是内部方法的具体功能代码};

因此，其实静态代理的例子当中也将Thread类进行lambda表达式的简化

new Thread( ()-> System.out.println("结婚啦！")).start();

放这儿让大家细品。

其实lambda表达式和静态代理关系还蛮密切，大家可以放一块儿用。