JAVA多线程03——静态代理、Lambda简化函数式接口的实现

一、静态代理

//测试静态代理
//真实对象和代理对象都要实现同一个接口  ****
//代理对象要代理角色

//代理对象做真实角色做不了的角色
public class StaticProxy {
    public static void main(String[] args) {
        WedingCompany wedingCompany = new WedingCompany(new Person("张三"));
        wedingCompany.HappyMarry();

        Thread t1 = new Thread(()-> {System.out.println("Thread代理Runable接口");});
        t1.start();
    }
}

interface Marry{
    void HappyMarry();
}

//真实角色
class Person implements Marry{
    private String person;
    public Person(String person) {
        this.person=person;
    }

    @Override
    public void HappyMarry(){
        System.out.println(person+"超开心");
    }
}

//代理
class WedingCompany implements Marry{

    private Person person;
    //构造方法传入结婚的对象
    public WedingCompany(Person person) {
        this.person = person;
    }
    @Override
    public void HappyMarry() {
        before();
        this.person.HappyMarry();
        after();
    }

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

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

二、Lamda表达式

可以让你的代码看起来很简洁

去掉了一堆没有意义的代码，只留下核心的逻辑。

函数式接口的定义：

       任何接口，如果只包含唯一一个抽象方法，那么它就是一个 函数式接口

                public interface Runnable {

                        public abstract void run();

                }

     对于函数式接口，我们可以通过lambda表达式来创建该接口的对象。 

1、普通的

2、静态内部类

3、局部内部类

4、匿名内部类

5、Lambda

从最普通的到Lambda一步步的简化

public class TestLambdm {

    //静态内部类
    static class Like2 implements TLike{
        @Override
        public void lambda() {
            System.out.println("I like lambda2");
        }
    }

    public static void main(String[] args) {
        Like like = new Like();
        like.lambda();

        Like2 like2 = new Like2();
        like2.lambda();

        //局部内部类
        class Like3 implements TLike{
            @Override
            public void lambda() {
                System.out.println("I like lambda3");
            }}
        new Like3().lambda();

        //匿名内部类
        TLike like4 = new TLike(){
            @Override
            public void lambda() {
                System.out.println("I like lambda4");
            }
        };
        like4.lambda();

        //使用lambda简化
        TLike like5 = () -> {
            System.out.println("I like lambda5");
        };
        like5.lambda();

    }
}
//定义一个函数式接口
interface TLike{
    void lambda();
}
class Like implements TLike{
    @Override
    public void lambda() {
        System.out.println("I like lambda1");
    }
}

public class TestLambda {
    public static void main(String[] args) {
        Ilove love = (int a)->{
            System.out.println("I love s"+a);
        };
        love.say(4);
    }
}


interface Ilove{
    void say(int s);
}

总结

• lambda表达式单行可简化大括号；
• lambda的前提是函数式接口（只要一个方法）
• 单参数也可去掉参数类型，但必须加上大括号