Java线程拓展 初学 第二部分

静态代理模式

首先以结婚为例:

• 你：真实角色
• 婚庆公司：代理你，帮你处理结婚的事
• 结婚：实现结婚接口即可

package com.thread.demo02;
// 实现静态代理对比Thread
import sun.applet.resources.MsgAppletViewer;
// 静态代理模式总结：
// 真实对象和代理对象都要实现同一接口
// 代理对象要代理真实角色

// 好处：
// 代理对象可以做很多真实对象做不了的事情
// 真实对象专注做自己的事情
public class StaticProxy {
    public static void main(String[] args) {
        You you = new You();
        new Thread(()-> System.out.println("我爱你")).start();// 对比Thread
        new WeddingCompany(new 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("zzy要结婚了，超开心");
    }
}
// 代理角色，帮助你结婚
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 after() {
        System.out.println("结婚之后，收尾款");
    }


    private void before() {
        System.out.println("结婚之前，布置现场");
    }
}

Lambda表达式

• λ 希腊字母表中排序第十一位的字母,英语名称为 Lambda
• 避免匿名内部类定义过多
• 其实质属于函数式编程的概念

• 为什么要使用Lambda表达式
  • 避免匿名内部类定义过多
  • 可以让你的代码看起来很简洁
  • 去掉了一堆没有意义的代码，只留下核心的逻辑。
• 理解 Functional Interface(函数式接口)是学习Java8 lambda表达式的关键所在。
• 函数式接口的定义:
  • 任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口。

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

/*
推导Lambda表达式
 */
public class TestLambda1 {
    // 3.静态内部类
    static class Like2 implements ILike{

        @Override
        public void lambda() {
            System.out.println("i like 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 lambda3");
            }
        }
        like = new Like3();
        like.lambda();

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

        // 6.用Lambda表达式简化
        like = ()->{
            System.out.println("i like lambda5");
        };
        like.lambda();
    }

}
// 1.定义一个函数接口
interface ILike{
    void lambda();
}

// 2.实现类
class Like implements ILike{

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

感谢B站狂神说，让我学到这些
希望我的教程能帮助到你，如有不足之处，希望大佬指出