静态代理及lambda表达式

lambda表达式
lambda是java8的新特性，现在都已经15了，再不学下真的要被骂了hhh

函数式接口

介绍lambda表达式之前说说函数式接口，函数式接口和普通接口没有什么区别，唯一的区别就是函数式接口只有一个抽象方法，只要一个接口中只有一个方法，那么该接口就可以被称为函数式接口。

lambda与其他形式的对比

最普通方式，某一个类实现一个接口，就称为该类是这个接口的实现类，通过创建实现类对象可以调用实现方法

interface USB{
	void usbSize();
}
class Vivo implements USB{
    public void usbSize(){
        System.out.println("vivo手机的USB尺寸");
    }
}
public class Test{
    public static void mian(String[] args){
        USB vivo = new Vivo();
        vivo.usbSize();	
    }
}

匿名内部类方式，匿名内部类的形式没有类的名称，通过抽象类名和接口来实现抽象方法

interface USB{
	void usbSize();
}
public class Test{
    public static void mian(String[] args){
        USB xiaoMi = new USB(){
        	public void usbSize() {
                System.out.println("小米手机的USB尺寸");
            }
        };
    }
}

lambda表达式的形式

interface USB{
	void usbSize();
}
public class Test{
    public static void mian(String[] args){
        USB huaWei = ()->{
        	System.out.println("华为手机的USB尺寸");
        };
    }
}

其中，(形参列表)->{

抽象方法usbSize的具体实现

}

当形参列表没有时，直接写()->{}的形式，即上面的例子
当形参列表有多个参数时，参数类型可以不写，直接写(a,b)->{}的形式，如果不写参数类型则所有参数类型都不能写
当形参列表只有一个参数时，可以省掉小括号，直接写a->{}的形式
当实现方法中只有一条语句时，大括号可以省略掉，直接写a->System.out.println(“华为手机的USB尺寸”);

通过对比，可以发现lambda表达式是匿名内部类的精简版，但其自身也有很多限制，其一，lambda表达式虽然简化代码但可读性变差了，其二，lambda表达式只适用于函数式接口，即只能重写接口一个方法

静态代理模式

静态代理是，接口的实现类并不直接创建对象调用实现方法，而是将实现类对象交给另一个实现类，即交给代理类，由代理类去执行实现类中的实现方法，代理类还可以在执行实现方法前后加入自己的方法，使得程序更加健壮。
Thread就是典型的代理类，Thread类也是实现了Runnable接口，当我们自定义类实现Runnable接口后，将自定义类对象通过Thread构造方法交给Thread后，由Thread类代替我们去执行我们的实现方法，即调用start方法。
下面以一个例子说明

Marry接口

public interface Marry {
    void happyMarry();
}

You自定义实现类

public class You implements Marry {
    @Override
    public void happyMarry() {
        System.out.println("俺要结婚啦，，，");
    }
}

Wedding代理类

public class Wedding implements Marry {
    Marry marry;

    public Wedding(Marry marry) {
        this.marry = marry;
    }

    @Override
    public void happyMarry() {
        System.out.println("代理类中的实现方法可以不写任何东西");
    }

    public void start() {
        beforeMarry();
        marry.happyMarry();
        afterMarry();
    }

    private void afterMarry() {
        System.out.println("结婚后，找新郎新娘结账");
    }

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

StaticProxy测试类

public class StaticProxy{
    public static void main(String[] args) {
        /*
        * You类和Wedding代理类都继承Marry接口，将You类对象交给代理类去执行
        * */
        /*You you = new You();
        new Wedding(you).start();*/

        //匿名内部类
        /*new Wedding(new Marry() {
            @Override
            public void happyMarry() {
                System.out.println("洞房花烛夜");
            }
        }).start();*/

        //lambda,因为Marry接口只有一个抽象方法，所以也可以用lambda方式
        new Wedding(()-> System.out.println("送入洞房")).start();

        //Thread的lambda方式
	//new Thread(()-> System.out.println("自定义类中的实现方法")).start();
    }
}