多线程的学习2-------------静态代理+lambda表达式

静态代理

静态代理需要达到两个要求：

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

2.代理对象要代理真实的角色

好处：

代理对象可以做真实对象做不了的事情，真实对象只专注于自己的事情。

示例：我请婚庆公司帮我准备婚礼

package com.xct.test;


//静态代理
public class StaticProxy {
    public static void main(String[] args) {
        WeddingCompany weddingCompany = new WeddingCompany(new You());
        weddingCompany.marry();
    }
}
    //接口
    interface Marry{
        //接口里面放要代理的事情
        void marry();
    }

    //真实对象
    class You implements Marry{
        @Override
        public void marry() {
            System.out.println("今天姐姐结婚了，好开心");
        }
    }

    //代理对象
    class WeddingCompany implements Marry{

        //代理的真实角色
        private Marry target;

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

        @Override
        public void marry() {
            //结婚前
            before();
            //结婚时
            target.marry();
            //结婚后
            after();
        }

        private void before() {
            System.out.println("结婚前布置房间");
        }

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

Lambda表达式

Lambda表达式是JDK8的一个新特性，可以取代大部分的匿名内部类，可以极大的优化代码结构。

注意：使用Lambda表达式的前提是接口必须是函数式接口，即只包含一个抽象方法。

jdk 8 中有另一个新特性：default， 被 default 修饰的方法会有默认实现，不是必须被实现的方法，所以不影响 Lambda 表达式的使用。

@FunctionalInterface

修饰函数式接口的，要求接口中的抽象方法只有一个。 这个注解往往会和 lambda 表达式一起出现。

示例：写出Lambda表达式的推导过程

package com.xct.test;
//学习lambda表达式
public class Lambda {
    //2.静态内部类
    static class ASX2 implements ILike{
        @Override
        public void like() {
            System.out.println("i like 1ambda2");
        }
    }

    public static void main(String[] args) {

        //3.局部内部类
        class ASX3 implements ILike{
            @Override
            public void like() {
                System.out.println("i like 1ambda3");
            }
        }

        //用函数式接口创建子类对象
        ILike a1 = new ASX();
        a1.like();

        a1 = new ASX2();
        a1.like();

        a1 = new ASX3();
        a1.like();


        //4.匿名内部类
        a1 = new ILike() {
            @Override
            public void like() {
                System.out.println("i like lambda4");
            }
        };
        a1.like();

        //5.Lambda表达式
        a1 = ()->{
            System.out.println("i like lambda5");
        };
        a1.like();
    }
}

//函数式接口
@FunctionalInterface
interface ILike{
    void like();
}

//1.实现接口
class ASX implements ILike{
    @Override
    public void like() {
        System.out.println("i like 1ambda1");
    }
}

示例：使用Lambda表达式创建线程

package com.xct.test;
//使用Lambda表达式创建线程
public class Lambda3{

    public static void main(String[] args) {
       new Thread(()->{
                System.out.println(Thread.currentThread().getName());
        }).start();

       Runnable r = ()->{
           System.out.println(Thread.currentThread().getName());
       };
       r.run();
    }
}

示例：练习Lambda表达式带参数

package com.xct.test;
//练习lambda表达式带参数
public class Lambda2 {
    public static void main(String[] args) {

        ILove l = null;

        //lambda表达式
        l = (a,b)->{
            System.out.println("a"+a+",b"+b);
            return 1;
        };
        l.love(404,200);
    }
}


//函数式接口
@FunctionalInterface
interface ILove{
    int love(int a,int b);
}

注意：Lambda表达式中的闭包问题

示例：查看Lambda表达式中的闭包问题

package com.xct.test;
//Lambda表达式中的闭包问题
public class Lambda4 {
    public static void main(String[] args) {
        int num = 20;
        IPackgeOver iPackgeOver;
        iPackgeOver = (a,b)->{
            System.out.println(a+b);
            System.out.println(num);
        };
//        num = num+2;

        iPackgeOver.getSun(10,20);


    }
}

//函数式接口
@FunctionalInterface
interface IPackgeOver{
    void getSun(int a,int b);
}

如图所示：

这个问题我们在匿名内部类中也会存在，如果我们把注释放开会报错，告诉我 num 值是 final 不能被改变。这里我们虽然没有标识 num 类型为 final，但是在编译期间虚拟机会帮我们加上 final 修饰关键字。

总结

1.Lambda表达式只能有一行代码的情况下才能简化为一行，如果有多行，那么就用代码块包裹。

2.使用Lambda表达式的前提是函数时接口。

3.多个参数也可以去掉参数类型，要去掉就都去掉，必须加上括号。