关于多线程的静态代理和Lamda表达式

多线程

关于线程的创建问题，请参考关于线程的创建问题

静态代理

真实对象和代理对象都要实现同一接口
代理对象要代理真实对象

//静态代理模式
//真实对象和代理对象都要实现同一接口
//代理对象要代理真实对象


//代理对象做真实对象做不了的事情
//真实对象专注做自己的事情
public class StacticProxy {
    public static void main(String[] args) {
        
        new Thread(()-> System.out.println("i love u")).start();
//
//        You you = new You();
//        you.HappyMarry();
        WeddingCompany weddingCompany = new WeddingCompany(new You());
        weddingCompany.HappyMarry();
    }
}

//结婚的接口
interface Marry{
    void HappyMarry();
}

//真实角色
class You implements Marry{
    @Override
    public void HappyMarry() {
        System.out.println("Happy");
    }
}

//代理角色，承包
class WeddingCompany implements Marry{

    private Marry target;  //结婚对象

    public WeddingCompany(Marry target) {  //初始化 目标对象
        this.target=target;
    }

    public WeddingCompany(){

    }

    //重写方法
    @Override
    public void HappyMarry() {
        before();  //前
        this.target.HappyMarry();  // you.HappyMarry();  //传入Marry target=new You(); 接口对象引用实现类实例  i=o
        after();  //后
    }

    private void before(){
        System.out.println("before");
    }

    private void after(){
        System.out.println("after");
    }
    
}

4 Lamda表达式

函数式接口：任何接口只包含唯一 一个抽象方法

//lamda表达式可以将全部参数类型都简化

public class TestLamda01 {

    //3.静态内部类
    static class Like2 implements ILike{
        @Override
        public void lamda(int i) {
            System.out.println("i love u2");
        }
    }
    public static void main(String[] args) {

        //1.
        ILike like=new Like();
        like.lamda(1);

        //2.
        like=new Like2();
        like.lamda(1);

        //3.局部内部类
        class Like3 implements ILike{
            @Override
            public void lamda(int i) {
                System.out.println("i love u3");
            }
        }

        like=new Like3();
        like.lamda(1);

        //4.匿名内部类  实现一个抽象类或者一个接口
        like=new ILike() {
            @Override
            public void lamda(int i) {
                System.out.println("i love u4");
            }
        };
        like.lamda(1);

        //5.lamda简化
        like=(int i)->{
            System.out.println("i love u5");
        };
        like.lamda(1);

        //5.1简化参数类型
        like=(i)->{
            System.out.println("i love u5.1");
        };
        like.lamda(1);

        //5.2
        like=i->{
            System.out.println("i love u5.2");
        };
        like.lamda(1);

        //5.3  代码只有一行简化花括号
        like=i-> System.out.println("i love u5.3");

        like.lamda(1);
    }
}

//1.定义一个函数式接口
interface ILike{
    void lamda(int i);
}

//2.实现类
class Like implements ILike{
    @Override
    public void lamda(int i) {
        System.out.println("i love u1");
    }
}