65.【 多线程2】（二）

自定义一个接口的方法:
interface 接口的名字{
  void 接口的方法名();
}
eg:
interface Marry{
    void marry();
}

1.什么是代理:就是帮助雇主完成某项任务
静态代理模式总结:
（1）.真实对象要和代理对象实现同一个接口
（2）.代理对象要代理真是对象
静态代理模式的优点:
（3）.代理对象可以帮助真实对象做一些真实对象做不了的事情
（4）.真实对象可以更加专注的只做一件事情

普通代理模式:

public class Demo6 {
    public static void main(String[] args) {
        You you=new You();
        Wedding_company wedding_company=new Wedding_company(you);
        wedding_company.marry();
    }
    //久旱逢甘露
    //他乡遇故知
    //洞烛花房夜
    //金榜题名时
}
共同接口
interface Marry{
    void marry();
}
真实对象
class You implements Marry{
    @Override
    public void marry() {
        System.out.println("李老师结婚了，超开心!");
    }
}
代理对象
class Wedding_company implements Marry{
private Marry target;
    public Wedding_company(Marry target) {
        this.target = target;
    }
    @Override
    public void marry() {
        before_marry();
        target.marry();
        after_marry();
    }
    public void before_marry(){
        System.out.println("结婚之前布置场景");
    }
    public void after_marry(){
        System.out.println("结婚之后收尾款");
    }
}

多线程实现静态代理模式

//代理实现Runnable 接口
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("我爱你!");
            }
        }).start();
        new Wedding_company(new You()).marry();

public class Demo6 {
    public static void main(String[] args) {
        //代理实现Runnable 接口
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("我爱你!");
            }
        }).start();
        new Wedding_company(new You()).marry();
    }
    //久旱逢甘露
    //他乡遇故知
    //洞烛花房夜
    //金榜题名时
}
interface Marry{
    void marry();
}
//真实的你
class You implements Marry{
    @Override
    public void marry() {
        System.out.println("李老师结婚了，超开心!");
    }
}
//婚庆公司
class Wedding_company implements Marry{
private Marry target;
    public Wedding_company(Marry target) {
        this.target = target;
    }
    @Override
    public void marry() {
        before_marry();
        target.marry();
        after_marry();
    }
    public void before_marry(){
        System.out.println("结婚之前布置场景");
    }
    public void after_marry(){
        System.out.println("结婚之后收尾款");
    }
}

（一）、什么是:
1.希腊字母表中排序第11位的字母: lambda
2.避免匿名内部类定义过多
3.其实质属于函数式编程的概念
（二）、为什么要使用lambda表达式?
1.避免匿名内部类定义过多
2.可以让你的代码看起来很简洁
3.去掉了一堆没有意义的代码，只留下核心的逻辑
（三）、函数式接口
函数式接口的定义:
1.任何接口，如果只包含唯一一个抽象方法，那么他就是一个函数式接口。
eg :
public interface Runnable(){
  public abstract void run();
}
2.对于函数式接口，我们可以通过lambda表达式来创建该接口的对象。
lamdb基本格式:
接口类对象=抽象方法的()->{"表达式"};

接口类对象需要被实现。
1.外部类
2.静态内部类
3.局部内部类
4.匿名类
5.lamdbad

public class Demo7 {
    //3.静态内部类:
    static class ILike_two implements ILike{
        @Override
        public void lambda() {
            System.out.println("I LIKE LAMBDA two!");
        }
    }
    public static void main(String[] args) {
        //创建一个接口类对象 以及实现类的对象+
        ILike like=new ILike_one();
        like.lambda();
        like=new ILike_two();
        like.lambda();
    //4.局部内部类:
    class ILike_three implements ILike{
        @Override
        public void lambda() {
            System.out.println("I LIKE LAMBDA three!");
        }
    }
        like=new ILike_three();
        like.lambda();
    //5.匿名内部类
        like= new ILike() {
        @Override
        public void lambda() {
            System.out.println("I LIKE LAMBDA four!");
        }
    };
        like.lambda();
    //6.用lambda简化
    like=()->{
        System.out.println("I LIKE LAMBDA five!");
         };
    like.lambda();
    }
}
//1.定义一个函数式接口
interface ILike{
    void lambda();
}
//2.实现类:
class ILike_one implements ILike{
    @Override
    public void lambda() {
        System.out.println("I LIKE LAMBDA !");
    }
}

public class Demo8 {
    //2.静态内部类
    static class Love_1 implements I_Love {
        @Override
        public void love(int a) {
            System.out.println("i love you  " + a);
        }
        public static void main(String[] args) {
            I_Love i_love = new Love();
            i_love.love(1);
            i_love=new Love_1();
            i_love.love(2);
        //3.局部内部类
            class Love_2 implements I_Love {
                @Override
                public void love(int a) {
                    System.out.println("i love you  " + a);
                }
            }
            i_love=new Love_2();
            i_love.love(3);
        //4.匿名内部类
        i_love=new I_Love() {
            @Override
            public void love(int a) {
                System.out.println("i love you  " + a);
            }
        };
        i_love.love(4);
        //5.lamdba
            i_love = (int a) -> {
                System.out.println(" i love you " + a);
            };
            i_love.love(5);
            //5.1  简化1（参数类型）
            i_love = a-> {
                System.out.println(" i love you " + a);
            };
            i_love.love(6);
            //5.2  简化2（括号（单个参数））
            i_love = (int a) -> {
                System.out.println(" i love you " + a);
            };
            i_love.love(7);
            //5.3  简化3(花括号（单行）)
            i_love = (int a) ->
                System.out.println(" i love you " + a);
            i_love.love(8);
        }
    }
}
interface I_Love {
    void love(int a);
}
//外部类:
class Love implements I_Love {
    @Override
    public void love(int a) {
        System.out.println("i love you " + a);
    }
}