【Java-II】多线程详解 P9-10（Day14、15-20210713、14-Day2、3）

09 静态代理

package threadLearn.demo02;

//静态代理模式总结：
    //真实对象和代理对象都要使用同一个接口
    //代理对象要代理真实角色，代理对象

//好处：
    //代理对象可以做真实对象做不了的事情
    //真实对象专注做自己的事情
public class StaticProxy {
    public static void main(String[] args) {

        
        You you = new You();
        WeddingCompany weddingCompany = new WeddingCompany(you);
        weddingCompany.HappyMarry();
    }
}

interface Marry{
    //人生四大喜事之一：结婚
    void HappyMarry();
}

//真实角色，你去结婚
class You implements Marry{
    @Override
    public void HappyMarry() {
        System.out.println("小明要结婚了");
    }
}

//代理角色，帮助你结婚
class WeddingCompany implements Marry{
    //代理谁？->真实目标角色
    private Marry target;

    public WeddingCompany(Marry target) {
        this.target = target;
    }

    @Override

    public void HappyMarry() {
        //结婚前的准备
        before();
        this.target.HappyMarry();//这就是真实对象
        after();
    }

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

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

Thread也是代理，代理是Thread的实现原理

对比Thread和代理

()->函数体

10 Lamda表达式

package threadLearn.lambda;
/*
推导lambda表达式
 */

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

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

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

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

        like = new Like3();
        like.lambda();

        //5. 匿名内部类，没有类的名称，必须借助接口或者父类
        new ILike() {
            @Override
            public void lambda() {
                System.out.println("i like lambda4");
            }
        }.lambda();

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

interface ILike{
    void lambda();
}

class Like implements ILike{
    @Override
    public void lambda() {
        System.out.println("i like lambda1");
    }
}

package threadLearn.lambda;

public class TestLambda2 {
    static class Love2 implements ILove{
        @Override
        public void love(int a) {
            System.out.println("i love you-->"+a);
        }
    }
    public static void main(String[] args) {
        ILove love = new Love();
        love.love(2);

        love=new Love2();
        love.love(3);

        class Love3 implements ILove{
            @Override
            public void love(int a) {
                System.out.println("i love you-->"+a);
            }
        }
        love=new Love3();
        love.love(4);

        love=new ILove() {
            @Override
            public void love(int a) {
                System.out.println("i love you-->"+a);
            }
        };
        love.love(5);

        //lambda表达式
        love=(int a)->{
            System.out.println("i love you-->"+a);
        };
        love.love(111);
        //简化1：去掉变量类型
        love=(a)->{
            System.out.println("i love you-->"+a);
        };
        love.love(222);

        //简化2：去掉括号
        love=a->{
            System.out.println("i love you-->"+a);
        };
        love.love(333);
        //简化3：去掉花括号
        love=a->System.out.println("i love you-->"+a);
        love.love(555);

        //总结：
        //lambda表达式，只有在只有一行代码的情况和下，才能进行去掉花括号简化成一行代码的形式
        //前提是接口为函数式接口
        //多个参数也可以去掉参数类型，要去掉都去掉，必须加上括号
    }
}
interface ILove{
    void love(int a);
}

class Love implements ILove{
    @Override
    public void love(int a) {
        System.out.println("i love you -->"+a);
    }
}

输出：

i love you -->2
i love you-->3
i love you-->4
i love you-->5
i love you-->111
i love you-->222
i love you-->333
i love you-->555