Java多线程-——静态代理以及Lambda表达式（基于狂神说的学习笔记）

静态代理

package demo02;

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

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

        // Thread 实现了runnable接口，相当于runnable接口的代理，并最后实现了runnable接口的start方法
        new Thread(()-> System.out.println("这里使用线程与lambda")).start();
        new WeddingCompany(new You()).HappyMarry();
        

    }
}

interface Marry{
    void HappyMarry();
}

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

// 代理角色
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 before() {
        System.out.println("布置场景");
    }
    private void after() {
        System.out.println("收尾款");
    }
}

Lambda表达式

Lambda表达式的出现是为了：

• 避免匿名内部类定义过多
• 其实质属于函数式编程的概念

例如：

new Thread(()->System.out.println("多线程-----")).start();

为什么要使用lambda表达式：

• 避免匿名内部类定义过多
• 可以让代码看起来更简洁
• 去掉没有意义的代码，只留下核心的逻辑

理解Functional Interface（函数式接口）：

函数式接口的定义：

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

public interface Runnable{
    // 一个接口只包含一个抽象方法
    public abstract void run();
}

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

对于实现函数式接口的多种形式：实现类，静态内部类，局部内部类，匿名内部类，lambda表达式

/*
推导lambda表达式
 */
public class TestLambda {

    // 3.静态内部类
    static class Like2 implements ILike{
        @Override
        public void lambda() {
            System.out.println("I like a 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 a lambda3.");
            }
        }
        // 测试局部内部类
        like = new Like3();
        like.lambda();

        // 5.匿名内部类，没有类的名称，必须要借助接口或者父类
        like = new ILike(){

            @Override
            public void lambda() {
                System.out.println("I like a lambda4");
            }
        };
        like.lambda();

        //6.用lambda表达式简化
        // 因为like是接口的一个实现对象，而该接口为函数式接口（仅有一个抽象方法）
        // 因此可以在实现抽象方法时可以省略其名字，就变成了lambda表达式
        like = ()->{
            System.out.println("I like a lambda5");
        };
        like.lambda();
    }

}

//1.定义一个函数式接口
interface ILike{
    void lambda();
}
//2.实现类
class Like implements ILike{

    @Override
    public void lambda() {
        System.out.println("I like a lambda.");
    }
}

Lambda表达式的多种简化形式

public class TestLambda2 {

    public static void main(String[] args) {
        ILambda iLambda = null;
        // 1.lambda表达式
        iLambda = (int a )->{
            System.out.println("This is lambda"+a);
        };
        // 2.简化数据类型
        iLambda = (a)->{
            System.out.println("This is lambda"+a);
        };
        // 3.简化括号
        iLambda = a -> {
            System.out.println("This is lambda"+a);
        };
        // 4. 简化花括号
        iLambda = a -> System.out.println("This is lambda"+a);
        iLambda.lambda(10);
    }

}

interface ILambda{
    void lambda(int a );
}