Java多线程：静态代理,Lamda表达式

静态代理

案例：

package com.kuang.demo02;

//静态代理
public class StaticProxy {
    public static void main(String[] args) {
        //代理对象  代理 真实对象
        You you = new You();
        you.happyMarry();
        new WeddingCompany(you).happyMarry();
    }
}

//真实对象：你
class You implements Marry{

    @Override
    public void happyMarry() {
        System.out.println("我要结婚了，好hi呦");
    }
}


//代理对象：婚庆公司
class WeddingCompany implements Marry{

    //婚庆需要有你这个人 ， 代理对象需要代理一个真实对象
    private Marry you;

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

    @Override
    public void happyMarry() {
        before();
        this.you.happyMarry();//你要结婚
        after();
    }

    private void before() {
        System.out.println("结婚之前，布置洞房");
    }
    private void after() {
        System.out.println("结婚之后，催你收钱");
    }

}


//共同的接口：结婚
interface Marry{
    void happyMarry();
}

Lamda表达式

• 概述

1. λ 希腊字母表中排序第十一位的字母，英语名称为Lambda
2. 避免匿名内部类定义过多
3. 其实质属于函数式编程的概念
   （params）-> expression [ 表达式 ]
   （params）-> statement [ 语句 ]
   （params）-> { statements }

• 为什么要使用Lamda表达式?

1. 避免匿名内部类定义过多
2. 可以让你的代码看起来很简洁
3. 去掉了一堆没有意义的代码，只留下核心的逻辑。
4. 也许你会说，我看了Lambda表达式，不但不觉得简洁，反
   而觉得更乱，看不懂了。那是因为我们还没有习惯，用的多
   了，看习惯了，就好了。

• 函数式接口的概念

1. 理解Functional Interface（函数式接口）是学习Java8 lambda表达式的关键所在。
2. 函数式接口的定义：
3. 任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口。
4. 对于函数式接口，我们可以通过lambda表达式来创建该接口的对象。
   public interface Runnable {
   public abstract void run();
   }

案例一：

public class Test01 {

    //静态内部类
    static class Test02 implements Runnable{
        @Override
        public void run() {
            System.out.println("你好呀lambda！");
        }
    }


    public static void main(String[] args) {
        Test02 test02 = new Test02();
        new Thread(test02).start();

        //局部内部类
        class Test03 implements Runnable{
            @Override
            public void run() {
                System.out.println("你好呀lambda2！");
            }
        }

        Test03 test03 = new Test03();
        new Thread(test03).start();


        //匿名内部类, 需要有一个借口或者父类
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("你好呀lambda3！");
            }
        }).start();

        //lambda  jdk.8新增方式
        new Thread(()->{
            System.out.println("你好呀lambda4！");
        }).start();


    }
}

案例二：

//lambda表达式前提
//必须是函数式接口.
//必须有返回值(就是那个函数式接口)

public class Test02 {

    public static void main(String[] args) {
        //lambda表达式
        ILike like = ()->{
            System.out.println("我讨厌lambda。。。。5");
        };

        like.lambda();

    }
}


//函数式接口
interface ILike{
    void lambda();
}

Lamda表达式简化写法

//lambda表达式传递参数
//隐式前提
// 只有一个参数的情况下,可以简化参数类型 , 参数括号 .
// 只有一行代码的情况下 , 可以省略大括号
案例：

public class Test03 {
    public static void main(String[] args) {
        ILove love = new Love();
        love.lambda(1);

        //匿名内部类
        love = new ILove() {
            @Override
            public void lambda(int a) {
                System.out.println("我开始喜欢lambda了...."+a);
            }
        };
        love.lambda(2);


        //lambda表达式
        love = (int a)->{
            System.out.println("我开始喜欢lambda了...."+a);
        };
        love.lambda(3);


        //简化1: 去掉括号
        love = a->{
            System.out.println("我开始喜欢lambda了...."+a);
        };
        love.lambda(4);


        //简化2:去掉花括号
        love = a->System.out.println("我开始喜欢lambda了...."+a);

        love.lambda(5);

    }
}


//函数式接口
interface ILove{
    void lambda(int a);
}

class Love implements ILove{
    @Override
    public void lambda(int a) {
        System.out.println("我开始喜欢lambda了...."+a);
    }
}

lambda表达式在多线程中的使用

案例：

//lambda表达式在多线程中的使用
public class Test04 {
    public static void main(String[] args) {

        //原先方式
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("你好二");
            }
        }).start();

        //线程体只有一行可以省略到极致
        new Thread(()-> System.out.println("你好二")).start();

        //如果线程体有多行 , 用一个代码块包裹起来就好.
        new Thread(()-> {
            for (int i = 0; i < 40; i++) {
                System.out.println("你好二");
            }
        }).start();

    }
}