静态代理、Lamda表达式

最新推荐文章于 2024-10-20 16:44:02 发布

原创最新推荐文章于 2024-10-20 16:44:02 发布 · 122 阅读

0 ·

CC 4.0 BY-SA版权

本文介绍了静态代理模式的应用及其实现方式，并通过实例展示了如何使用Lambda表达式简化代码。静态代理模式要求真实对象和代理对象实现相同的接口，代理对象可以在真实对象的基础上增加额外的功能。

静态代理

静态代理模式中真实对象和代理对象都要实现同一个接口，代理对象要代理真实角色

public class staticProxy {
    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("结婚之前，布置现场");
    }
}

在这里插入图片描述

好处：代理对象可做很多真实对象做不了的事情

Lambda表达式

如果接口只包含唯一一个抽象，那么它就是一个函数式接口；对于函数式接口，可以通过lambda表达式来创建该接口的对象

public class testLambda1 {
    //3.静态内部类
    static class Like2 implements ILike{
        @Override
        public void lambda() {
            System.out.println("I Like 2");
        }}
    public static  void main(String[] args) {

        ILike like = new Like();//接口去new一个实现类
        like.lambda();

        Like2 like2 = new Like2();
        like2.lambda();

        //4.局部内部类
        class Like3 implements ILike{
            @Override
            public void lambda() {
                System.out.println("I Like 3");
            }}
        Like3 like3 = new Like3();
        like3.lambda();

        //匿名内部类，没有类的名称，必须借助接口或者父类
        like =new ILike() {
            @Override
            public void lambda() {
                System.out.println("I Like 4");
            }
        };
        like.lambda();

        //6.用lambda简化
        like = ()->{
            System.out.println("I Like 5");
        };
        like.lambda();
    }
}

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

//2.实现类
class Like implements ILike{
    @Override
    public void lambda() {
        System.out.println("I Like ");
    }
}

只有一个接口和一个实现类，1到6是逐步简化过程。上面就是一个函数式接口，可用lambda简化

下面是带参数的

public class testLambda2 {
    public static void main(String[] args) {
        ILove love = new Love();
        love.love(2);
    }
}
interface ILove{
    void love(int a);
}

class Love implements ILove{
    @Override
    public void love(int a) {
        System.out.println("I love you-->"+a);
    }
}

与

public class testLambda2 {
    public static void main(String[] args) {
        ILove love = null;
        /*
        ILove love = (int a)->{
            System.out.println("I love you"+a);
        };
        //类型简化
        love = (a)-> {
            System.out.println("I love you"+a);
        };
        //简化括号
        love = a->{
            System.out.println("I love you"+a);
        };
        //去掉花括号

         */
        love =a->System.out.println("I love you"+a);

        love.love(521);
    }
}
interface ILove{
    void love(int a);
}

class Love implements ILove{
    @Override
    public void love(int a) {
        System.out.println("I love you-->"+a);
    }
}