【Java开发】JUC基础 02：Lambda表达式和静态代理模式

1 Lambda表达式

📌 作用

用于避免匿名内部类定义过多，去掉一些没有意义的代码，只留下核心的逻辑，其本质属于函数式编程的概念（jdk8新特性）。

比如之前通过Runnable创建线程，首先需要创建类实现Runnable接口，然后把实现类放入new出来的Thread才能调用start()方法。下边是Lambda表达式的效果👇，不用创建实现类了~

new Thread (()->System.out.print(“Lamda表达式”)).start();

目前可能不是很明白，不妨往下看~

1.1 函数式接口

理解函数式接口是学习Java 8 Lambda表达式的关键所在。

📌 定义

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

public interface Runnable {
    public abstract void run();
}

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

1.2 lamda表达式推导

首先需要创建一个接口，而且该接口只有一个抽象方法；然后注意看1-5的实现方式，这是一步步的简化，最终通过lanbda简化！

① lambda表达式推导

public class TestLambda {

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

    public static void main(String[] args) {
        //1.通过实现类
        ILike like = new Like1();
        like.lambda();

        //2.通过静态内部类
        like = new Like2();
        like.lambda();

        //3.局部内部类
        class Like3 implements ILike{
            @Override
            public void lambda() {
                System.out.println("I like Lambda3!");
            }
        }

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

        //4.匿名内部类,没有类的名称,必须借助接口或者父类
        like = new ILike() {
            @Override
            public void lambda() {
                System.out.println("I like Lambda4!");
            }
        };
        like.lambda();

        //5.用lanbda简化
        like = ()-> System.out.println("I like Lambda5!");
        like.lambda();
    }
}

//前提：定义一个函数式接口
interface ILike{
    void lambda();
}

//1.实现类
class Like1 implements ILike{
    @Override
    public void lambda() {
        System.out.println("I like Lambda1!");
    }
}

② 带参数lambda表达式

public class TestLambda2 {
    public static void main(String[] args) {
        ILove love = (String name)-> {System.out.println("love"+name);};
        love.love("小明");
    }
}

interface ILove{
    void love(String name);
}

③ 简化lambda表达式

public class TestLambda2 {
    public static void main(String[] args) {
        //1.lambda表示简化
        ILove love = (String name)-> {System.out.println("love"+name);};

        //简化1：参数类型
        love = (name) -> {System.out.println("love"+name);};

        //简化2：简化括号，多个参数去掉参数类型 必须加上括号。
        love = name -> {System.out.println("love"+name);};

        //简化3：花括号  只有一行代码的情况下可以简化花括号，多行代码必须使用代码块
        love = name -> System.out.println("love"+name);

        love.love("小明");
    }
}

interface ILove{
    void love(String name);
}

2 静态代理模式

其实多线程Thread底层使用了代理模式，掌握静态代理模式有助于我们更好地理解和学习多线程！

📌 要点

• 真实对象和代理对象都要去去实现同一个接口，代理对象需代理真实角色；

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

📢 看完代码，其实Merry接口等同于Runable接口，Runable接口也相当于是Thread类的一个target，那么就可以通过lambda表达式对其进行优化，不需要创建多余的实现类！

public class StaticProxy {
    public static void main(String[] args) {
        //放入You这个对象
        WeddingCompany weddingCompany = new WeddingCompany(new You());
        weddingCompany.happyMerry();

        //lambda简化
        new WeddingCompany(()-> System.out.println("lambda--结婚愉快")).happyMerry();

        //通过runable接口创建线程，使用lambda简化
        new Thread(()-> System.out.println("lambda--线程创建")).start();
    }
}

interface Merry {
    void happyMerry();
}

//真实角色--You
class You implements Merry{

    @Override
    public void happyMerry() {
        System.out.println("You--结婚愉快");
    }
}

//代理角色--婚庆公司
class WeddingCompany implements Merry{
    //目标
    private Merry target;

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

    @Override
    public void happyMerry() {
        before();
        this.target.happyMerry();
        after();
    }

    private void before() {
        System.out.println("布置现场");
    }

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