多线程（二）静态代理、Lamda表达式

多线程（二）静态代理、Lamda表达式

目录

• 多线程（二）静态代理、Lamda表达式
  • 静态代理模式
    • 概念
    • 好处
    • 代码实例
  • Lamda表达式（λ表达式）
    • Lamda表达式优点
    • 函数式接口
      • 定义
    • Lamda表达式的推导
      • 推导1（普通式子）
      • 推导2（类--》静态内部类--》局部内部类--》匿名内部类）
      • 推导3（上面式子--》Lambda表达式）
    • Lamda的表达
      • 表达1
      • 表达2（去掉小括号）
      • 表达式3（去掉花括号）
      • 表达式4（多个参数，多个式子）
    • Lamda注意事项

静态代理模式

概念

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

好处

• 代理对象能做真实对象做不了的
• 真实对象专注做自己的事情

代码实例

public class StacticProxy {
    public static void main(String[] args) {
        WeddingCompany weddingCompany = new WeddingCompany(new You());
        weddingCompany.HappyMarry();
    }
}
interface Marry{
    void HappyMarry();
}
//真实角色
class You implements Marry{

    @Override
    public void HappyMarry() {
        System.out.println("要结婚了");
    }
}
//代理角色
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("结婚之前布置现场");
    }
}
//输出：
结婚之前布置现场
要结婚了
结婚之后

Lamda表达式（λ表达式）

Lamda表达式优点

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

函数式接口

定义

• 任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口
• 通过函数式接口就可以创建抽象对象了

Lamda表达式的推导

推导1（普通式子）

//推导lambda表达式
public class TestLambda {
    public static void main(String[] args) {
        Like like = new Like();
        like.lambda();
    }
}
//1.定义一个函数式接口
interface ILike{
    void lambda();
}
//2.实现类
class Like implements ILike{
    @Override
    public void lambda() {
        System.out.println("i like lambda");
    }
}
//输出：
i like lambda

推导2（类--》静态内部类--》局部内部类--》匿名内部类）

//推导lambda表达式
public class TestLambda {
    //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();

    }
}
//1.定义一个函数式接口
interface ILike{
    void lambda();
}
//2.实现类
class Like implements ILike{
    @Override
    public void lambda() {
        System.out.println("i like lambda");
    }
}
//输出：
i like lambda
i like lambda2
i like lambda3
i like lambda4

推导3（上面式子--》Lambda表达式）

//推导lambda表达式
public class TestLambda {
    //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为函数式接口ILike类型（函数式接口：只有一个方法）
        //{}里实现的就是函数式接口里的唯一的方法
        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");
    }
}
//输出：
i like lambda
i like lambda2
i like lambda3
i like lambda4
i like lambda5

Lamda的表达

表达1

public class TestLambda2 {
    public static void main(String[] args) {
        ILove testLove = (int a)->{
            System.out.println("I love you-->"+a);
        };
        //使用
        testLove.love(3);
    }
}
interface ILove{
    void love(int a);
}
//输出：
I love you-->3

表达2（去掉小括号）

• 表达式有单行或多行时可以使用

public class TestLambda3 {
    public static void main(String[] args) {
        ILove2 lov=a->{
            System.out.println("I love you-->"+a);
        };
        lov.love(10);
    }
}
interface ILove2{
    void love(int a);
}
//输出：
I love you-->10

public class TestLambda3 {
    public static void main(String[] args) {
        ILove2 lov=null;
        lov=a->{
            System.out.println("I love you-->"+a);
        };
        lov.love(10);
    }
}
interface ILove2{
    void love(int a);
}
//输出：
I love you-->10

表达式3（去掉花括号）

• 只有表达式只有一行的时候才能去掉花括号

public class TestLambda3 {
    public static void main(String[] args) {
        ILove2 lov=a->System.out.println("I love you-->"+a);//表达式只有System.out.println("I love you-->"+a)一行，所以可以去掉花括号
        lov.love(16);
    }
}
interface ILove2{
    void love(int a);
}
//输出：
I love you-->16

表达式4（多个参数，多个式子）

• 当有多个参数时，参数用小括号包裹，lambda里参数可以不带参数类型（但是要不带就都不带）

public class TestLambda4 {
    public static void main(String[] args) {
        ILove3 l1=(a,b,c)->{
            System.out.println("a="+a);
            System.out.println("b="+b);
            System.out.println("所以"+c+"说"+(a+b));
        };
        l1.love(6,7,"史小鹏");
    }
}
interface ILove3{
    void love(int a,int b,String c);
}
//输出：
a=6
b=7
所以史小鹏说13

Lamda注意事项

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