Java多线程拓展之静态代理和Lamda表达式演变

• 一、静态代理
• • 1、概念
  • • 2、优点
    • 3、样例
• 二、Lamda表达式（演变过程展示）
• • 1、定义一个函数式接口并实现类（最初状态）
  • 2、静态内部类（状态演变2）
  • 3、局部内部类（状态演变3）
  • 4、匿名内部类（状态演变4）
  • 5、用lambda简化（状态演变5）
  • 6、用lambda简化一（去掉参数类型）
  • 7、用lambda简化二（简化括号）
  • 8、用lambda简化三（去掉花括号）
  • 9、注意

一、静态代理

1、概念

真实对象和代理对象都要实现同一个接口
代理对象要代理真实角色

2、优点

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

3、样例

package com.example.multithreading.demo3;public class StaticProxy {public static void main(String[] args) {You you = new You();
//        1、没加多线程的操作
//        WeddingCompany weddingCompany = new WeddingCompany(you);
//        weddingCompany.HappyMarray();// 2、使用多线程的操作new Thread(() ->System.out.println("开始")).start();new WeddingCompany(new You()).HappyMarray();}
}interface Marray{void HappyMarray();
}// 真实角色
class You implements Marray{@Overridepublic void HappyMarray(){System.out.println("主体操作");}
}// 代理角色
class WeddingCompany implements Marray{//代理真实目标角色private Marray target;public WeddingCompany(Marray target) {this.target = target;}@Overridepublic void HappyMarray(){before();// 这就是真实对象this.target.HappyMarray();after();}private void before(){System.out.println("代理之前的操作");}private void after(){System.out.println("代理之后的操作");}
}

结果

二、Lamda表达式（演变过程展示）

1、定义一个函数式接口并实现类（最初状态）

一开始是定义一个接口。然后主程序调用成功。

package com.example.multithreading.demo4;/*** 推导lambda表达式*/
public class lamda {public static void main(String[] args) {Ilike like = new Like();like.lambda(1);}
}// 1、定义一个函数式接口
interface Ilike{void lambda(int a);
}// 2、实现类
class Like implements Ilike {@Overridepublic void lambda(int a) {System.out.println("lambda:" + a);}
}

结果

2、静态内部类（状态演变2）

演变成静态内部类，再调用成功

package com.example.multithreading.demo4;/*** 推导lambda表达式*/
public class lamda {// 3、静态内部类static class Like2 implements Ilike{@Overridepublic void lambda(int a){System.out.println("lambda2:" + a);}}public static void main(String[] args) {Ilike like = new Like2();like.lambda(2);}
}// 1、定义一个函数式接口
interface Ilike{void lambda(int a);
}

结果

3、局部内部类（状态演变3）

演变成局部内部类，发现调用依然正常

package com.example.multithreading.demo4;/*** 推导lambda表达式*/
public class lamda {public static void main(String[] args) {// 4、局部内部类class Like3 implements Ilike{@Overridepublic void lambda(int a) {System.out.println("lambda3:" + a);}}Ilike like = new Like3();like.lambda(3);}
}// 1、定义一个函数式接口
interface Ilike{void lambda(int a);
}

结果

4、匿名内部类（状态演变4）

将其简化成匿名内部类后依然调用成功

package com.example.multithreading.demo4;/*** 推导lambda表达式*/
public class lamda {public static void main(String[] args) {// 5、匿名内部类，没有类的名称，必须借助接口或者父类Ilike like = new Ilike() {@Overridepublic void lambda(int a) {System.out.println("lambda4:" + a);}};like.lambda(4);}
}// 1、定义一个函数式接口
interface Ilike{void lambda(int a);
}

结果

5、用lambda简化（状态演变5）

package com.example.multithreading.demo4;/*** 推导lambda表达式*/
public class lamda {public static void main(String[] args) {// 6、用lambda简化Ilike like = (int a) -> {System.out.println("lambda5:" + a);};like.lambda(5);}
}// 1、定义一个函数式接口
interface Ilike{void lambda(int a);
}

结果

6、用lambda简化一（去掉参数类型）

package com.example.multithreading.demo4;/*** 推导lambda表达式*/
public class lamda {public static void main(String[] args) {// 7、用lambda简化二Ilike like = (a) -> {System.out.println("lambda5:" + a);};like.lambda(6);}
}// 1、定义一个函数式接口
interface Ilike{void lambda(int a);
}

结果

7、用lambda简化二（简化括号）

package com.example.multithreading.demo4;/*** 推导lambda表达式*/
public class lamda {public static void main(String[] args) {// 8、用lambda简化三Ilike like = a -> {System.out.println("lambda5:" + a);};like.lambda(7);}
}// 1、定义一个函数式接口
interface Ilike{void lambda(int a);
}

结果

8、用lambda简化三（去掉花括号）

package com.example.multithreading.demo4;/*** 推导lambda表达式*/
public class lamda {public static void main(String[] args) {// 9、用lambda简化四Ilike like = a -> System.out.println("lambda5:" + a);like.lambda(8);}
}// 1、定义一个函数式接口
interface Ilike{void lambda(int a);
}

结果

9、注意

lambda表达式只能有一行代码的情况下才能简化成为一行，如果有多行，那么就用代码块包裹。
前提是接口为函数式接口。
多个参数也可以去掉参数类型，要去掉就都去掉，必须加上括号。